// (c) 2022 and onwards The vChewing Project (LGPL v3.0 License or later).
// ====================
// This code is released under the SPDX-License-Identifier: `LGPL-3.0-or-later`.

#include "../Sources/Tekkon/include/Tekkon.hh"
#include "gtest/gtest.h"

namespace Tekkon {

void checkEq(std::vector<std::string>* container, Composer* composer,
             std::string keyStrokes, std::string strExpected) {
  std::string strResult = composer->receiveSequence(keyStrokes);
  if (strResult == strExpected) return;
  std::string errorStr = "MISMATCH:" + keyStrokes + " -> \"" + strResult +
                         "\" != \"" + strExpected + "\"";
  std::cout << errorStr;
  container->push_back(errorStr);
}

TEST(TekkonTests_Basic, InitializingPhonabet) {
  Phonabet thePhonabetNull = Phonabet("0");
  Phonabet thePhonabetA = Phonabet("ㄉ");
  Phonabet thePhonabetB = Phonabet("ㄧ");
  Phonabet thePhonabetC = Phonabet("ㄠ");
  Phonabet thePhonabetD = Phonabet("ˇ");
  ASSERT_EQ(thePhonabetNull.type, PhoneType::null);
  ASSERT_EQ(thePhonabetA.type, PhoneType::consonant);
  ASSERT_EQ(thePhonabetB.type, PhoneType::semivowel);
  ASSERT_EQ(thePhonabetC.type, PhoneType::vowel);
  ASSERT_EQ(thePhonabetD.type, PhoneType::intonation);
}

TEST(TekkonTests_Basic, IsValidKeyWithKeys) {
  bool result;
  Tekkon::Composer composer = Composer("", ofDachen);

  /// Testing Failed Key
  result = composer.inputValidityCheck(0x0024);
  ASSERT_FALSE(result);

  // Testing Correct Qwerty Dachen Key
  composer.ensureParser(ofDachen);
  result = composer.inputValidityCheck(0x002F);
  ASSERT_TRUE(result);

  // Testing Correct ETen26 Key
  composer.ensureParser(ofETen26);
  result = composer.inputValidityCheck(0x0062);
  ASSERT_TRUE(result);

  // Testing Correct Hanyu-Pinyin Key
  composer.ensureParser(ofHanyuPinyin);
  result = composer.inputValidityCheck(0x0062);
  ASSERT_TRUE(result);
}

// =========== COMPOSER POKAYOKE TESTS ===========

TEST(TekkonTests_Basic, PhonabetCombinationCorrection) {
  Composer composer = Composer("", ofDachen, true);

  composer.receiveKeyFromPhonabet("ㄓ");
  composer.receiveKeyFromPhonabet("ㄧ");
  composer.receiveKeyFromPhonabet("ˋ");
  ASSERT_EQ(composer.value(), "ㄓˋ");

  composer.clear();
  composer.receiveKeyFromPhonabet("ㄓ");
  composer.receiveKeyFromPhonabet("ㄩ");
  composer.receiveKeyFromPhonabet("ˋ");
  ASSERT_EQ(composer.value(), "ㄐㄩˋ");

  composer.clear();
  composer.receiveKeyFromPhonabet("ㄓ");
  composer.receiveKeyFromPhonabet("ㄧ");
  composer.receiveKeyFromPhonabet("ㄢ");
  ASSERT_EQ(composer.value(), "ㄓㄢ");

  composer.clear();
  composer.receiveKeyFromPhonabet("ㄓ");
  composer.receiveKeyFromPhonabet("ㄩ");
  composer.receiveKeyFromPhonabet("ㄢ");
  ASSERT_EQ(composer.value(), "ㄐㄩㄢ");

  composer.clear();
  composer.receiveKeyFromPhonabet("ㄓ");
  composer.receiveKeyFromPhonabet("ㄧ");
  composer.receiveKeyFromPhonabet("ㄢ");
  composer.receiveKeyFromPhonabet("ˋ");
  ASSERT_EQ(composer.value(), "ㄓㄢˋ");

  composer.clear();
  composer.receiveKeyFromPhonabet("ㄓ");
  composer.receiveKeyFromPhonabet("ㄩ");
  composer.receiveKeyFromPhonabet("ㄢ");
  composer.receiveKeyFromPhonabet("ˋ");
  ASSERT_EQ(composer.value(), "ㄐㄩㄢˋ");
}

// =========== PHONABET TYPINNG HANDLING TESTS (BASIC) ===========

TEST(TekkonTests_Basic, PhonabetKeyReceivingAndCompositions) {
  Composer composer = Composer("", ofDachen);
  bool toneMarkerIndicator;

  // Test Key Receiving;
  composer.receiveKey(0x0032);  // 2, ㄉ
  composer.receiveKey("j");     // ㄨ
  composer.receiveKey("u");     // ㄧ
  composer.receiveKey("l");     // ㄠ

  // Testing missing tone markers;
  toneMarkerIndicator = composer.hasIntonation();
  ASSERT_TRUE(!toneMarkerIndicator);

  composer.receiveKey("3");  // 上聲
  ASSERT_EQ(composer.value(), "ㄉㄧㄠˇ");
  composer.doBackSpace();
  composer.receiveKey(" ");  // 陰平
  ASSERT_EQ(composer.value(),
            "ㄉㄧㄠ ");  // 這裡回傳的結果的陰平是空格

  // Test Getting Displayed Composition
  ASSERT_EQ(composer.getComposition(), "ㄉㄧㄠ");
  ASSERT_EQ(composer.getComposition(true, false),
            "diao1");  // 中階測試項目
  ASSERT_EQ(composer.getComposition(true, true),
            "diāo");  // 中階測試項目
  ASSERT_EQ(composer.getInlineCompositionForDisplay(true),
            "diao1");  // 中階測試項目

  // Test Tone 5
  composer.receiveKey("7");  // 輕聲
  ASSERT_EQ(composer.getComposition(), "ㄉㄧㄠ˙");
  ASSERT_EQ(composer.getComposition(false, true),
            "˙ㄉㄧㄠ");  // 中階測試項目

  // Testing having tone markers
  toneMarkerIndicator = composer.hasIntonation();
  ASSERT_TRUE(toneMarkerIndicator);

  // Testing having not-only tone markers
  toneMarkerIndicator = composer.hasIntonation(true);
  ASSERT_TRUE(!toneMarkerIndicator);

  // Testing having only tone markers
  composer.clear();
  composer.receiveKey("3");  // 上聲
  toneMarkerIndicator = composer.hasIntonation(true);
  ASSERT_TRUE(toneMarkerIndicator);

  // Testing auto phonabet combination fixing process.
  composer.phonabetCombinationCorrectionEnabled = true;

  // Testing exceptions of handling "ㄅㄨㄛ ㄆㄨㄛ ㄇㄨㄛ ㄈㄨㄛ"
  composer.clear();
  composer.receiveKey("1");
  composer.receiveKey("j");
  composer.receiveKey("i");
  ASSERT_EQ(composer.getComposition(), "ㄅㄛ");
  composer.receiveKey("q");
  ASSERT_EQ(composer.getComposition(), "ㄆㄛ");
  composer.receiveKey("a");
  ASSERT_EQ(composer.getComposition(), "ㄇㄛ");
  composer.receiveKey("z");
  ASSERT_EQ(composer.getComposition(), "ㄈㄛ");

  // Testing exceptions of handling "ㄅㄨㄥ ㄆㄨㄥ ㄇㄨㄥ ㄈㄨㄥ"
  composer.clear();
  composer.receiveKey("1");
  composer.receiveKey("j");
  composer.receiveKey("/");
  ASSERT_EQ(composer.getComposition(), "ㄅㄥ");
  composer.receiveKey("q");
  ASSERT_EQ(composer.getComposition(), "ㄆㄥ");
  composer.receiveKey("a");
  ASSERT_EQ(composer.getComposition(), "ㄇㄥ");
  composer.receiveKey("z");
  ASSERT_EQ(composer.getComposition(), "ㄈㄥ");

  // Testing exceptions of handling "ㄋㄨㄟ ㄌㄨㄟ"
  composer.clear();
  composer.receiveKey("s");
  composer.receiveKey("j");
  composer.receiveKey("o");
  ASSERT_EQ(composer.getComposition(), "ㄋㄟ");
  composer.receiveKey("x");
  ASSERT_EQ(composer.getComposition(), "ㄌㄟ");

  // Testing exceptions of handling "ㄧㄜ ㄩㄜ"
  composer.clear();
  composer.receiveKey("s");
  composer.receiveKey("k");
  composer.receiveKey("u");
  ASSERT_EQ(composer.getComposition(), "ㄋㄧㄝ");
  composer.receiveKey("s");
  composer.receiveKey("m");
  composer.receiveKey("k");
  ASSERT_EQ(composer.getComposition(), "ㄋㄩㄝ");
  composer.receiveKey("s");
  composer.receiveKey("u");
  composer.receiveKey("k");
  ASSERT_EQ(composer.getComposition(), "ㄋㄧㄝ");

  // Testing exceptions of handling "ㄨㄜ ㄨㄝ"
  composer.clear();
  composer.receiveKey("j");
  composer.receiveKey("k");
  ASSERT_EQ(composer.getComposition(), "ㄩㄝ");
  composer.clear();
  composer.receiveKey("j");
  composer.receiveKey(",");
  ASSERT_EQ(composer.getComposition(), "ㄩㄝ");
  composer.clear();
  composer.receiveKey(",");
  composer.receiveKey("j");
  ASSERT_EQ(composer.getComposition(), "ㄩㄝ");
  composer.clear();
  composer.receiveKey("k");
  composer.receiveKey("j");
  ASSERT_EQ(composer.getComposition(), "ㄩㄝ");

  // Testing tool functions
  ASSERT_EQ(Tekkon::restoreToneOneInPhona("ㄉㄧㄠ"), "ㄉㄧㄠ1");
  ASSERT_EQ(Tekkon::cnvPhonaToTextbookStyle("ㄓㄜ˙"), "˙ㄓㄜ");
  ASSERT_EQ(Tekkon::cnvPhonaToHanyuPinyin("ㄍㄢˋ"), "gan4");
  ASSERT_EQ(Tekkon::cnvHanyuPinyinToTextBookStyle("起(qi3)居(ju1)"),
            "起(qǐ)居(jū)");
  ASSERT_EQ(Tekkon::cnvHanyuPinyinToPhona("bian4"), "ㄅㄧㄢˋ");
  ASSERT_EQ(Tekkon::cnvHanyuPinyinToPhona("bian4-le5-tian1"),
            "ㄅㄧㄢˋ-ㄌㄜ˙-ㄊㄧㄢ");
  // 測試這種情形：「如果傳入的字串不包含任何半形英數內容的話，那麼應該直接將傳入的字串原樣返回」。
  ASSERT_EQ(Tekkon::cnvHanyuPinyinToPhona("ㄅㄧㄢˋ-˙ㄌㄜ-ㄊㄧㄢ"),
            "ㄅㄧㄢˋ-˙ㄌㄜ-ㄊㄧㄢ");
}

// =========== PINYIN TYPINNG HANDLING TESTS ===========

TEST(TekkonTests_Intermediate, HanyuinyinKeyReceivingAndCompositions) {
  Composer composer = Composer("", ofHanyuPinyin);
  bool toneMarkerIndicator;

  // Test Key Receiving
  composer.receiveKey(100);  // d
  composer.receiveKey("i");
  composer.receiveKey("a");
  composer.receiveKey("o");
  ASSERT_EQ(composer.consonant.value(), "ㄉ");
  ASSERT_EQ(composer.semivowel.value(), "ㄧ");
  ASSERT_EQ(composer.vowel.value(), "ㄠ");

  // Testing missing tone markers;
  toneMarkerIndicator = composer.hasIntonation();
  ASSERT_TRUE(!toneMarkerIndicator);

  composer.receiveKey("3");  // 上聲
  ASSERT_EQ(composer.value(), "ㄉㄧㄠˇ");
  composer.doBackSpace();
  composer.receiveKey(" ");  // 陰平
  ASSERT_EQ(composer.value(),
            "ㄉㄧㄠ ");  // 這裡回傳的結果的陰平是空格

  // Test Getting Displayed Composition;
  ASSERT_EQ(composer.getComposition(), "ㄉㄧㄠ");
  ASSERT_EQ(composer.getComposition(true, false), "diao1");
  ASSERT_EQ(composer.getComposition(true, true), "diāo");
  ASSERT_EQ(composer.getInlineCompositionForDisplay(true), "diao1");

  // Test Tone 5
  composer.receiveKey("7");  // 輕聲
  ASSERT_EQ(composer.getComposition(), "ㄉㄧㄠ˙");
  ASSERT_EQ(composer.getComposition(false, true), "˙ㄉㄧㄠ");

  // Testing having tone markers
  toneMarkerIndicator = composer.hasIntonation();
  ASSERT_TRUE(toneMarkerIndicator);

  // Testing having not-only tone markers
  toneMarkerIndicator = composer.hasIntonation(true);
  ASSERT_TRUE(!toneMarkerIndicator);

  // Testing having only tone markers
  composer.clear();
  composer.receiveKey("3");  // 上聲
  toneMarkerIndicator = composer.hasIntonation(true);
  ASSERT_TRUE(toneMarkerIndicator);
}

TEST(TekkonTests_Intermediate, SecondaryPinyinKeyReceivingAndCompositions) {
  Composer composer = Composer("", ofSecondaryPinyin);
  bool toneMarkerIndicator;

  // Test Key Receiving
  composer.receiveKey(99);  // c
  composer.receiveKey("h");
  composer.receiveKey("i");
  composer.receiveKey("u");
  composer.receiveKey("n");
  composer.receiveKey("g");
  ASSERT_EQ(composer.consonant.value(), "ㄑ");
  ASSERT_EQ(composer.semivowel.value(), "ㄩ");
  ASSERT_EQ(composer.vowel.value(), "ㄥ");

  // Testing missing tone markers
  toneMarkerIndicator = composer.hasIntonation();
  ASSERT_TRUE(!toneMarkerIndicator);

  composer.receiveKey("2");  // 陽平
  ASSERT_EQ(composer.value(), "ㄑㄩㄥˊ");
  composer.doBackSpace();
  composer.receiveKey(" ");  // 陰平
  ASSERT_EQ(composer.value(),
            "ㄑㄩㄥ ");  // 這裡回傳的結果的陰平是空格

  // Test Getting Displayed Composition;
  ASSERT_EQ(composer.getComposition(), "ㄑㄩㄥ");
  ASSERT_EQ(composer.getComposition(true, false), "qiong1");
  ASSERT_EQ(composer.getComposition(true, true), "qiōng");
  ASSERT_EQ(composer.getInlineCompositionForDisplay(true), "chiung1");

  // Test Tone 5
  composer.receiveKey("7");  // 輕聲
  ASSERT_EQ(composer.getComposition(), "ㄑㄩㄥ˙");
  ASSERT_EQ(composer.getComposition(false, true), "˙ㄑㄩㄥ");

  // Testing having tone markers
  toneMarkerIndicator = composer.hasIntonation();
  ASSERT_TRUE(toneMarkerIndicator);

  // Testing having not-only tone markers
  toneMarkerIndicator = composer.hasIntonation(true);
  ASSERT_TRUE(!toneMarkerIndicator);

  // Testing having only tone markers
  composer.clear();
  composer.receiveKey("3");  // 上聲
  toneMarkerIndicator = composer.hasIntonation(true);
  ASSERT_TRUE(toneMarkerIndicator);
}

TEST(TekkonTests_Intermediate, YalePinyinKeyReceivingAndCompositions) {
  Composer composer = Composer("", ofYalePinyin);
  bool toneMarkerIndicator;

  // Test Key Receiving
  composer.receiveKey(99);  // c
  composer.receiveKey("h");
  composer.receiveKey("y");
  composer.receiveKey("u");
  composer.receiveKey("n");
  composer.receiveKey("g");
  ASSERT_EQ(composer.consonant.value(), "ㄑ");
  ASSERT_EQ(composer.semivowel.value(), "ㄩ");
  ASSERT_EQ(composer.vowel.value(), "ㄥ");

  // Testing missing tone markers
  toneMarkerIndicator = composer.hasIntonation();
  ASSERT_TRUE(!toneMarkerIndicator);

  composer.receiveKey("2");  // 陽平
  ASSERT_EQ(composer.value(), "ㄑㄩㄥˊ");
  composer.doBackSpace();
  composer.receiveKey(" ");  // 陰平
  ASSERT_EQ(composer.value(),
            "ㄑㄩㄥ ");  // 這裡回傳的結果的陰平是空格

  // Test Getting Displayed Composition;
  ASSERT_EQ(composer.getComposition(), "ㄑㄩㄥ");
  ASSERT_EQ(composer.getComposition(true, false), "qiong1");
  ASSERT_EQ(composer.getComposition(true, true), "qiōng");
  ASSERT_EQ(composer.getInlineCompositionForDisplay(true), "chyung1");

  // Test Tone 5
  composer.receiveKey("7");  // 輕聲
  ASSERT_EQ(composer.getComposition(), "ㄑㄩㄥ˙");
  ASSERT_EQ(composer.getComposition(false, true), "˙ㄑㄩㄥ");

  // Testing having tone markers
  toneMarkerIndicator = composer.hasIntonation();
  ASSERT_TRUE(toneMarkerIndicator);

  // Testing having not-only tone markers
  toneMarkerIndicator = composer.hasIntonation(true);
  ASSERT_TRUE(!toneMarkerIndicator);

  // Testing having only tone markers
  composer.clear();
  composer.receiveKey("3");  // 上聲
  toneMarkerIndicator = composer.hasIntonation(true);
  ASSERT_TRUE(toneMarkerIndicator);
}

TEST(TekkonTests_Intermediate, HualuoPinyinKeyReceivingAndCompositions) {
  Composer composer = Composer("", ofHualuoPinyin);
  bool toneMarkerIndicator;

  // Test Key Receiving
  composer.receiveKey(99);  // c
  composer.receiveKey("h");
  composer.receiveKey("y");
  composer.receiveKey("o");
  composer.receiveKey("n");
  composer.receiveKey("g");
  ASSERT_EQ(composer.consonant.value(), "ㄑ");
  ASSERT_EQ(composer.semivowel.value(), "ㄩ");
  ASSERT_EQ(composer.vowel.value(), "ㄥ");

  // Testing missing tone markers
  toneMarkerIndicator = composer.hasIntonation();
  ASSERT_TRUE(!toneMarkerIndicator);

  composer.receiveKey("2");  // 陽平
  ASSERT_EQ(composer.value(), "ㄑㄩㄥˊ");
  composer.doBackSpace();
  composer.receiveKey(" ");  // 陰平
  ASSERT_EQ(composer.value(),
            "ㄑㄩㄥ ");  // 這裡回傳的結果的陰平是空格

  // Test Getting Displayed Composition
  ASSERT_EQ(composer.getComposition(), "ㄑㄩㄥ");
  ASSERT_EQ(composer.getComposition(true, false), "qiong1");
  ASSERT_EQ(composer.getComposition(true, true), "qiōng");
  ASSERT_EQ(composer.getInlineCompositionForDisplay(true), "chyong1");

  // Test Tone 5
  composer.receiveKey("7");  // 輕聲
  ASSERT_EQ(composer.getComposition(), "ㄑㄩㄥ˙");
  ASSERT_EQ(composer.getComposition(false, true), "˙ㄑㄩㄥ");

  // Testing having tone markers
  toneMarkerIndicator = composer.hasIntonation();
  ASSERT_TRUE(toneMarkerIndicator);

  // Testing having not-only tone markers
  toneMarkerIndicator = composer.hasIntonation(true);
  ASSERT_TRUE(!toneMarkerIndicator);

  // Testing having only tone markers
  composer.clear();
  composer.receiveKey("3");  // 上聲
  toneMarkerIndicator = composer.hasIntonation(true);
  ASSERT_TRUE(toneMarkerIndicator);
}

TEST(TekkonTests_Intermediate, UniversalPinyinKeyReceivingAndCompositions) {
  Composer composer = Composer("", ofUniversalPinyin);
  bool toneMarkerIndicator;

  // Test Key Receiving
  composer.receiveKey(99);  // c
  composer.receiveKey("y");
  composer.receiveKey("o");
  composer.receiveKey("n");
  composer.receiveKey("g");
  ASSERT_EQ(composer.consonant.value(), "ㄑ");
  ASSERT_EQ(composer.semivowel.value(), "ㄩ");
  ASSERT_EQ(composer.vowel.value(), "ㄥ");

  // Testing missing tone markers
  toneMarkerIndicator = composer.hasIntonation();
  ASSERT_TRUE(!toneMarkerIndicator);

  composer.receiveKey("2");  // 陽平
  ASSERT_EQ(composer.value(), "ㄑㄩㄥˊ");
  composer.doBackSpace();
  composer.receiveKey(" ");  // 陰平
  ASSERT_EQ(composer.value(),
            "ㄑㄩㄥ ");  // 這裡回傳的結果的陰平是空格

  // Test Getting Displayed Composition
  ASSERT_EQ(composer.getComposition(), "ㄑㄩㄥ");
  ASSERT_EQ(composer.getComposition(true, false), "qiong1");
  ASSERT_EQ(composer.getComposition(true, true), "qiōng");
  ASSERT_EQ(composer.getInlineCompositionForDisplay(true), "cyong1");

  // Test Tone 5
  composer.receiveKey("7");  // 輕聲
  ASSERT_EQ(composer.getComposition(), "ㄑㄩㄥ˙");
  ASSERT_EQ(composer.getComposition(false, true), "˙ㄑㄩㄥ");

  // Testing having tone markers
  toneMarkerIndicator = composer.hasIntonation();
  ASSERT_TRUE(toneMarkerIndicator);

  // Testing having not-only tone markers
  toneMarkerIndicator = composer.hasIntonation(true);
  ASSERT_TRUE(!toneMarkerIndicator);

  // Testing having only tone markers
  composer.clear();
  composer.receiveKey("3");  // 上聲
  toneMarkerIndicator = composer.hasIntonation(true);
  ASSERT_TRUE(toneMarkerIndicator);
}

TEST(TekkonTests_Intermediate, WadeGilesPinyinKeyReceivingAndCompositions) {
  Composer composer = Composer("", ofWadeGilesPinyin);
  bool toneMarkerIndicator;

  // Test Key Receiving
  composer.receiveKey(99);  // c
  composer.receiveKey("h");
  composer.receiveKey("'");  // 韋氏拼音清濁分辨鍵
  composer.receiveKey("i");
  composer.receiveKey("u");
  composer.receiveKey("n");
  composer.receiveKey("g");

  // Testing missing tone markers
  toneMarkerIndicator = composer.hasIntonation();
  ASSERT_TRUE(!toneMarkerIndicator);

  composer.receiveKey("2");  // 陽平
  ASSERT_EQ(composer.value(), "ㄑㄩㄥˊ");
  composer.doBackSpace();
  composer.receiveKey(" ");  // 陰平
  ASSERT_EQ(composer.value(),
            "ㄑㄩㄥ ");  // 這裡回傳的結果的陰平是空格

  // Test Getting Displayed Composition
  ASSERT_EQ(composer.getComposition(), "ㄑㄩㄥ");
  ASSERT_EQ(composer.getComposition(true, false), "qiong1");
  ASSERT_EQ(composer.getComposition(true, true), "qiōng");
  ASSERT_EQ(composer.getInlineCompositionForDisplay(true), "ch'iung1");

  // Test Tone 5
  composer.receiveKey("7");  // 輕聲
  ASSERT_EQ(composer.getComposition(), "ㄑㄩㄥ˙");
  ASSERT_EQ(composer.getComposition(false, true), "˙ㄑㄩㄥ");

  // Testing having tone markers
  toneMarkerIndicator = composer.hasIntonation();
  ASSERT_TRUE(toneMarkerIndicator);

  // Testing having not-only tone markers
  toneMarkerIndicator = composer.hasIntonation(true);
  ASSERT_TRUE(!toneMarkerIndicator);

  // Testing having only tone markers
  composer.clear();
  composer.receiveKey("3");  // 上聲
  toneMarkerIndicator = composer.hasIntonation(true);
  ASSERT_TRUE(toneMarkerIndicator);
}

// =========== PHONABET TYPINNG HANDLING TESTS (ADVANCED) ===========

TEST(TekkonTests_Advanced, QwertyDachenKeys) {
  // Testing Dachen Traditional Mapping (QWERTY);
  Composer c = Composer("", ofDachen);
  std::vector<std::string> container = {};
  checkEq(&container, &c, "18 ", "ㄅㄚ ");
  checkEq(&container, &c, "m,4", "ㄩㄝˋ");
  checkEq(&container, &c, "5j/ ", "ㄓㄨㄥ ");
  checkEq(&container, &c, "fu.", "ㄑㄧㄡ");
  checkEq(&container, &c, "g0 ", "ㄕㄢ ");
  checkEq(&container, &c, "xup6", "ㄌㄧㄣˊ");
  checkEq(&container, &c, "xu;6", "ㄌㄧㄤˊ");
  checkEq(&container, &c, "z/", "ㄈㄥ");
  checkEq(&container, &c, "tjo ", "ㄔㄨㄟ ");
  checkEq(&container, &c, "284", "ㄉㄚˋ");
  checkEq(&container, &c, "2u4", "ㄉㄧˋ");
  checkEq(&container, &c, "hl3", "ㄘㄠˇ");
  checkEq(&container, &c, "5 ", "ㄓ ");
  checkEq(&container, &c, "193", "ㄅㄞˇ");
  ASSERT_TRUE(container.empty());
}

TEST(TekkonTests_Advanced, Dachen26Keys) {
  // Testing handleDachen26()
  Composer c = Composer("", ofDachen26);
  std::vector<std::string> container = {};
  checkEq(&container, &c, "dull", "ㄎㄧㄤ");
  checkEq(&container, &c, "eule", "ㄍㄧㄠˊ");
  checkEq(&container, &c, "eup", "ㄍㄧㄣ");
  checkEq(&container, &c, "qqulle", "ㄅㄧㄤˊ");
  checkEq(&container, &c, "qqulld", "ㄅㄧㄤˋ");
  checkEq(&container, &c, "wwjll", "ㄉㄨㄤ");
  checkEq(&container, &c, "qquu", "ㄅㄚ");
  checkEq(&container, &c, "qquue", "ㄅㄚˊ");
  checkEq(&container, &c, "qquur", "ㄅㄚˇ");
  checkEq(&container, &c, "qquud", "ㄅㄚˋ");
  checkEq(&container, &c, "qquuy", "ㄅㄚ˙");
  checkEq(&container, &c, "qqi", "ㄅㄛ");
  checkEq(&container, &c, "qqie", "ㄅㄛˊ");
  checkEq(&container, &c, "qqir", "ㄅㄛˇ");
  checkEq(&container, &c, "qqid", "ㄅㄛˋ");
  checkEq(&container, &c, "qqiy", "ㄅㄛ˙");
  checkEq(&container, &c, "qqii", "ㄅㄞ");
  checkEq(&container, &c, "qqiie", "ㄅㄞˊ");
  checkEq(&container, &c, "qqiir", "ㄅㄞˇ");
  checkEq(&container, &c, "qqiid", "ㄅㄞˋ");
  checkEq(&container, &c, "qqiiy", "ㄅㄞ˙");
  checkEq(&container, &c, "qqo", "ㄅㄟ");
  checkEq(&container, &c, "qqor", "ㄅㄟˇ");
  checkEq(&container, &c, "qqod", "ㄅㄟˋ");
  checkEq(&container, &c, "qqoy", "ㄅㄟ˙");
  checkEq(&container, &c, "qql", "ㄅㄠ");
  checkEq(&container, &c, "qqle", "ㄅㄠˊ");
  checkEq(&container, &c, "qqlr", "ㄅㄠˇ");
  checkEq(&container, &c, "qqld", "ㄅㄠˋ");
  checkEq(&container, &c, "qqoo", "ㄅㄢ");
  checkEq(&container, &c, "qqoor", "ㄅㄢˇ");
  checkEq(&container, &c, "qqood", "ㄅㄢˋ");
  checkEq(&container, &c, "qqp", "ㄅㄣ");
  checkEq(&container, &c, "qqpr", "ㄅㄣˇ");
  checkEq(&container, &c, "qqpd", "ㄅㄣˋ");
  checkEq(&container, &c, "qqll", "ㄅㄤ");
  checkEq(&container, &c, "qqllr", "ㄅㄤˇ");
  checkEq(&container, &c, "qqlld", "ㄅㄤˋ");
  checkEq(&container, &c, "qqn", "ㄅㄥ");
  checkEq(&container, &c, "qqne", "ㄅㄥˊ");
  checkEq(&container, &c, "qqnr", "ㄅㄥˇ");
  checkEq(&container, &c, "qqnd", "ㄅㄥˋ");
  checkEq(&container, &c, "qqu", "ㄅㄧ");
  checkEq(&container, &c, "qque", "ㄅㄧˊ");
  checkEq(&container, &c, "qqur", "ㄅㄧˇ");
  checkEq(&container, &c, "qqud", "ㄅㄧˋ");
  checkEq(&container, &c, "qqub", "ㄅㄧㄝ");
  checkEq(&container, &c, "qqube", "ㄅㄧㄝˊ");
  checkEq(&container, &c, "qqubr", "ㄅㄧㄝˇ");
  checkEq(&container, &c, "qqubd", "ㄅㄧㄝˋ");
  checkEq(&container, &c, "qqul", "ㄅㄧㄠ");
  checkEq(&container, &c, "qqulr", "ㄅㄧㄠˇ");
  checkEq(&container, &c, "qquld", "ㄅㄧㄠˋ");
  checkEq(&container, &c, "qquoo", "ㄅㄧㄢ");
  checkEq(&container, &c, "qquooe", "ㄅㄧㄢˊ");
  checkEq(&container, &c, "qquoor", "ㄅㄧㄢˇ");
  checkEq(&container, &c, "qquood", "ㄅㄧㄢˋ");
  checkEq(&container, &c, "qqup", "ㄅㄧㄣ");
  checkEq(&container, &c, "qqupr", "ㄅㄧㄣˇ");
  checkEq(&container, &c, "qqupd", "ㄅㄧㄣˋ");
  checkEq(&container, &c, "qqun", "ㄅㄧㄥ");
  checkEq(&container, &c, "qqunr", "ㄅㄧㄥˇ");
  checkEq(&container, &c, "qqund", "ㄅㄧㄥˋ");
  checkEq(&container, &c, "qqj", "ㄅㄨ");
  checkEq(&container, &c, "qqje", "ㄅㄨˊ");
  checkEq(&container, &c, "qqjr", "ㄅㄨˇ");
  checkEq(&container, &c, "qqjd", "ㄅㄨˋ");
  checkEq(&container, &c, "quu", "ㄆㄚ");
  checkEq(&container, &c, "quue", "ㄆㄚˊ");
  checkEq(&container, &c, "quur", "ㄆㄚˇ");
  checkEq(&container, &c, "quud", "ㄆㄚˋ");
  checkEq(&container, &c, "quuy", "ㄆㄚ˙");
  checkEq(&container, &c, "qi", "ㄆㄛ");
  checkEq(&container, &c, "qie", "ㄆㄛˊ");
  checkEq(&container, &c, "qir", "ㄆㄛˇ");
  checkEq(&container, &c, "qid", "ㄆㄛˋ");
  checkEq(&container, &c, "qii", "ㄆㄞ");
  checkEq(&container, &c, "qiie", "ㄆㄞˊ");
  checkEq(&container, &c, "qiir", "ㄆㄞˇ");
  checkEq(&container, &c, "qiid", "ㄆㄞˋ");
  checkEq(&container, &c, "qo", "ㄆㄟ");
  checkEq(&container, &c, "qoe", "ㄆㄟˊ");
  checkEq(&container, &c, "qor", "ㄆㄟˇ");
  checkEq(&container, &c, "qod", "ㄆㄟˋ");
  checkEq(&container, &c, "ql", "ㄆㄠ");
  checkEq(&container, &c, "qle", "ㄆㄠˊ");
  checkEq(&container, &c, "qlr", "ㄆㄠˇ");
  checkEq(&container, &c, "qld", "ㄆㄠˋ");
  checkEq(&container, &c, "qm", "ㄆㄡ");
  checkEq(&container, &c, "qme", "ㄆㄡˊ");
  checkEq(&container, &c, "qmr", "ㄆㄡˇ");
  checkEq(&container, &c, "qmd", "ㄆㄡˋ");
  checkEq(&container, &c, "qoo", "ㄆㄢ");
  checkEq(&container, &c, "qooe", "ㄆㄢˊ");
  checkEq(&container, &c, "qoor", "ㄆㄢˇ");
  checkEq(&container, &c, "qood", "ㄆㄢˋ");
  checkEq(&container, &c, "qp", "ㄆㄣ");
  checkEq(&container, &c, "qpe", "ㄆㄣˊ");
  checkEq(&container, &c, "qpr", "ㄆㄣˇ");
  checkEq(&container, &c, "qpd", "ㄆㄣˋ");
  checkEq(&container, &c, "qll", "ㄆㄤ");
  checkEq(&container, &c, "qlle", "ㄆㄤˊ");
  checkEq(&container, &c, "qllr", "ㄆㄤˇ");
  checkEq(&container, &c, "qlld", "ㄆㄤˋ");
  checkEq(&container, &c, "qn", "ㄆㄥ");
  checkEq(&container, &c, "qne", "ㄆㄥˊ");
  checkEq(&container, &c, "qnr", "ㄆㄥˇ");
  checkEq(&container, &c, "qnd", "ㄆㄥˋ");
  checkEq(&container, &c, "qu", "ㄆㄧ");
  checkEq(&container, &c, "que", "ㄆㄧˊ");
  checkEq(&container, &c, "qur", "ㄆㄧˇ");
  checkEq(&container, &c, "qud", "ㄆㄧˋ");
  checkEq(&container, &c, "quuu", "ㄆㄧㄚ");
  checkEq(&container, &c, "qub", "ㄆㄧㄝ");
  checkEq(&container, &c, "qubr", "ㄆㄧㄝˇ");
  checkEq(&container, &c, "qubd", "ㄆㄧㄝˋ");
  checkEq(&container, &c, "qul", "ㄆㄧㄠ");
  checkEq(&container, &c, "qule", "ㄆㄧㄠˊ");
  checkEq(&container, &c, "qulr", "ㄆㄧㄠˇ");
  checkEq(&container, &c, "quld", "ㄆㄧㄠˋ");
  checkEq(&container, &c, "quoo", "ㄆㄧㄢ");
  checkEq(&container, &c, "quooe", "ㄆㄧㄢˊ");
  checkEq(&container, &c, "quoor", "ㄆㄧㄢˇ");
  checkEq(&container, &c, "quood", "ㄆㄧㄢˋ");
  checkEq(&container, &c, "qup", "ㄆㄧㄣ");
  checkEq(&container, &c, "qupe", "ㄆㄧㄣˊ");
  checkEq(&container, &c, "qupr", "ㄆㄧㄣˇ");
  checkEq(&container, &c, "qupd", "ㄆㄧㄣˋ");
  checkEq(&container, &c, "qun", "ㄆㄧㄥ");
  checkEq(&container, &c, "qune", "ㄆㄧㄥˊ");
  checkEq(&container, &c, "qunr", "ㄆㄧㄥˇ");
  checkEq(&container, &c, "qund", "ㄆㄧㄥˋ");
  checkEq(&container, &c, "qj", "ㄆㄨ");
  checkEq(&container, &c, "qje", "ㄆㄨˊ");
  checkEq(&container, &c, "qjr", "ㄆㄨˇ");
  checkEq(&container, &c, "qjd", "ㄆㄨˋ");
  checkEq(&container, &c, "auu", "ㄇㄚ");
  checkEq(&container, &c, "auue", "ㄇㄚˊ");
  checkEq(&container, &c, "auur", "ㄇㄚˇ");
  checkEq(&container, &c, "auud", "ㄇㄚˋ");
  checkEq(&container, &c, "auuy", "ㄇㄚ˙");
  checkEq(&container, &c, "ai", "ㄇㄛ");
  checkEq(&container, &c, "aie", "ㄇㄛˊ");
  checkEq(&container, &c, "air", "ㄇㄛˇ");
  checkEq(&container, &c, "aid", "ㄇㄛˋ");
  checkEq(&container, &c, "aiy", "ㄇㄛ˙");
  checkEq(&container, &c, "ak", "ㄇㄜ");
  checkEq(&container, &c, "akd", "ㄇㄜˋ");
  checkEq(&container, &c, "aky", "ㄇㄜ˙");
  checkEq(&container, &c, "aii", "ㄇㄞ");
  checkEq(&container, &c, "aiie", "ㄇㄞˊ");
  checkEq(&container, &c, "aiir", "ㄇㄞˇ");
  checkEq(&container, &c, "aiid", "ㄇㄞˋ");
  checkEq(&container, &c, "aoe", "ㄇㄟˊ");
  checkEq(&container, &c, "aor", "ㄇㄟˇ");
  checkEq(&container, &c, "aod", "ㄇㄟˋ");
  checkEq(&container, &c, "al", "ㄇㄠ");
  checkEq(&container, &c, "ale", "ㄇㄠˊ");
  checkEq(&container, &c, "alr", "ㄇㄠˇ");
  checkEq(&container, &c, "ald", "ㄇㄠˋ");
  checkEq(&container, &c, "ame", "ㄇㄡˊ");
  checkEq(&container, &c, "amr", "ㄇㄡˇ");
  checkEq(&container, &c, "amd", "ㄇㄡˋ");
  checkEq(&container, &c, "aoo", "ㄇㄢ");
  checkEq(&container, &c, "aooe", "ㄇㄢˊ");
  checkEq(&container, &c, "aoor", "ㄇㄢˇ");
  checkEq(&container, &c, "aood", "ㄇㄢˋ");
  checkEq(&container, &c, "ap", "ㄇㄣ");
  checkEq(&container, &c, "ape", "ㄇㄣˊ");
  checkEq(&container, &c, "apr", "ㄇㄣˇ");
  checkEq(&container, &c, "apd", "ㄇㄣˋ");
  checkEq(&container, &c, "apy", "ㄇㄣ˙");
  checkEq(&container, &c, "all", "ㄇㄤ");
  checkEq(&container, &c, "alle", "ㄇㄤˊ");
  checkEq(&container, &c, "allr", "ㄇㄤˇ");
  checkEq(&container, &c, "alld", "ㄇㄤˋ");
  checkEq(&container, &c, "an", "ㄇㄥ");
  checkEq(&container, &c, "ane", "ㄇㄥˊ");
  checkEq(&container, &c, "anr", "ㄇㄥˇ");
  checkEq(&container, &c, "and", "ㄇㄥˋ");
  checkEq(&container, &c, "au", "ㄇㄧ");
  checkEq(&container, &c, "aue", "ㄇㄧˊ");
  checkEq(&container, &c, "aur", "ㄇㄧˇ");
  checkEq(&container, &c, "aud", "ㄇㄧˋ");
  checkEq(&container, &c, "aub", "ㄇㄧㄝ");
  checkEq(&container, &c, "aube", "ㄇㄧㄝˊ");
  checkEq(&container, &c, "aubd", "ㄇㄧㄝˋ");
  checkEq(&container, &c, "aul", "ㄇㄧㄠ");
  checkEq(&container, &c, "aule", "ㄇㄧㄠˊ");
  checkEq(&container, &c, "aulr", "ㄇㄧㄠˇ");
  checkEq(&container, &c, "auld", "ㄇㄧㄠˋ");
  checkEq(&container, &c, "aume", "ㄇㄧㄡˊ");
  checkEq(&container, &c, "aumr", "ㄇㄧㄡˇ");
  checkEq(&container, &c, "aumd", "ㄇㄧㄡˋ");
  checkEq(&container, &c, "auoo", "ㄇㄧㄢ");
  checkEq(&container, &c, "auooe", "ㄇㄧㄢˊ");
  checkEq(&container, &c, "auoor", "ㄇㄧㄢˇ");
  checkEq(&container, &c, "auood", "ㄇㄧㄢˋ");
  checkEq(&container, &c, "aup", "ㄇㄧㄣ");
  checkEq(&container, &c, "aupe", "ㄇㄧㄣˊ");
  checkEq(&container, &c, "aupr", "ㄇㄧㄣˇ");
  checkEq(&container, &c, "aune", "ㄇㄧㄥˊ");
  checkEq(&container, &c, "aunr", "ㄇㄧㄥˇ");
  checkEq(&container, &c, "aund", "ㄇㄧㄥˋ");
  checkEq(&container, &c, "aje", "ㄇㄨˊ");
  checkEq(&container, &c, "ajr", "ㄇㄨˇ");
  checkEq(&container, &c, "ajd", "ㄇㄨˋ");
  checkEq(&container, &c, "zuu", "ㄈㄚ");
  checkEq(&container, &c, "zuue", "ㄈㄚˊ");
  checkEq(&container, &c, "zuur", "ㄈㄚˇ");
  checkEq(&container, &c, "zuud", "ㄈㄚˋ");
  checkEq(&container, &c, "zie", "ㄈㄛˊ");
  checkEq(&container, &c, "zo", "ㄈㄟ");
  checkEq(&container, &c, "zoe", "ㄈㄟˊ");
  checkEq(&container, &c, "zor", "ㄈㄟˇ");
  checkEq(&container, &c, "zod", "ㄈㄟˋ");
  checkEq(&container, &c, "zm", "ㄈㄡ");
  checkEq(&container, &c, "zme", "ㄈㄡˊ");
  checkEq(&container, &c, "zmr", "ㄈㄡˇ");
  checkEq(&container, &c, "zmd", "ㄈㄡˋ");
  checkEq(&container, &c, "zoo", "ㄈㄢ");
  checkEq(&container, &c, "zooe", "ㄈㄢˊ");
  checkEq(&container, &c, "zoor", "ㄈㄢˇ");
  checkEq(&container, &c, "zood", "ㄈㄢˋ");
  checkEq(&container, &c, "zp", "ㄈㄣ");
  checkEq(&container, &c, "zpe", "ㄈㄣˊ");
  checkEq(&container, &c, "zpr", "ㄈㄣˇ");
  checkEq(&container, &c, "zpd", "ㄈㄣˋ");
  checkEq(&container, &c, "zpy", "ㄈㄣ˙");
  checkEq(&container, &c, "zll", "ㄈㄤ");
  checkEq(&container, &c, "zlle", "ㄈㄤˊ");
  checkEq(&container, &c, "zllr", "ㄈㄤˇ");
  checkEq(&container, &c, "zlld", "ㄈㄤˋ");
  checkEq(&container, &c, "zn", "ㄈㄥ");
  checkEq(&container, &c, "zne", "ㄈㄥˊ");
  checkEq(&container, &c, "znr", "ㄈㄥˇ");
  checkEq(&container, &c, "znd", "ㄈㄥˋ");
  checkEq(&container, &c, "zuld", "ㄈㄧㄠˋ");
  checkEq(&container, &c, "zj", "ㄈㄨ");
  checkEq(&container, &c, "zje", "ㄈㄨˊ");
  checkEq(&container, &c, "zjr", "ㄈㄨˇ");
  checkEq(&container, &c, "zjd", "ㄈㄨˋ");
  checkEq(&container, &c, "wwuu", "ㄉㄚ");
  checkEq(&container, &c, "wwuue", "ㄉㄚˊ");
  checkEq(&container, &c, "wwuur", "ㄉㄚˇ");
  checkEq(&container, &c, "wwuud", "ㄉㄚˋ");
  checkEq(&container, &c, "wwuuy", "ㄉㄚ˙");
  checkEq(&container, &c, "wwk", "ㄉㄜ");
  checkEq(&container, &c, "wwke", "ㄉㄜˊ");
  checkEq(&container, &c, "wwky", "ㄉㄜ˙");
  checkEq(&container, &c, "wwii", "ㄉㄞ");
  checkEq(&container, &c, "wwiir", "ㄉㄞˇ");
  checkEq(&container, &c, "wwiid", "ㄉㄞˋ");
  checkEq(&container, &c, "wwor", "ㄉㄟˇ");
  checkEq(&container, &c, "wwl", "ㄉㄠ");
  checkEq(&container, &c, "wwle", "ㄉㄠˊ");
  checkEq(&container, &c, "wwlr", "ㄉㄠˇ");
  checkEq(&container, &c, "wwld", "ㄉㄠˋ");
  checkEq(&container, &c, "wwm", "ㄉㄡ");
  checkEq(&container, &c, "wwme", "ㄉㄡˊ");
  checkEq(&container, &c, "wwmr", "ㄉㄡˇ");
  checkEq(&container, &c, "wwmd", "ㄉㄡˋ");
  checkEq(&container, &c, "wwoo", "ㄉㄢ");
  checkEq(&container, &c, "wwoor", "ㄉㄢˇ");
  checkEq(&container, &c, "wwood", "ㄉㄢˋ");
  checkEq(&container, &c, "wwpd", "ㄉㄣˋ");
  checkEq(&container, &c, "wwll", "ㄉㄤ");
  checkEq(&container, &c, "wwllr", "ㄉㄤˇ");
  checkEq(&container, &c, "wwlld", "ㄉㄤˋ");
  checkEq(&container, &c, "wwn", "ㄉㄥ");
  checkEq(&container, &c, "wwnr", "ㄉㄥˇ");
  checkEq(&container, &c, "wwnd", "ㄉㄥˋ");
  checkEq(&container, &c, "wwu", "ㄉㄧ");
  checkEq(&container, &c, "wwue", "ㄉㄧˊ");
  checkEq(&container, &c, "wwur", "ㄉㄧˇ");
  checkEq(&container, &c, "wwud", "ㄉㄧˋ");
  checkEq(&container, &c, "wwuuur", "ㄉㄧㄚˇ");
  checkEq(&container, &c, "wwub", "ㄉㄧㄝ");
  checkEq(&container, &c, "wwube", "ㄉㄧㄝˊ");
  checkEq(&container, &c, "wwubr", "ㄉㄧㄝˇ");
  checkEq(&container, &c, "wwubd", "ㄉㄧㄝˋ");
  checkEq(&container, &c, "wwul", "ㄉㄧㄠ");
  checkEq(&container, &c, "wwulr", "ㄉㄧㄠˇ");
  checkEq(&container, &c, "wwuld", "ㄉㄧㄠˋ");
  checkEq(&container, &c, "wwum", "ㄉㄧㄡ");
  checkEq(&container, &c, "wwuoo", "ㄉㄧㄢ");
  checkEq(&container, &c, "wwuooe", "ㄉㄧㄢˊ");
  checkEq(&container, &c, "wwuoor", "ㄉㄧㄢˇ");
  checkEq(&container, &c, "wwuood", "ㄉㄧㄢˋ");
  checkEq(&container, &c, "wwun", "ㄉㄧㄥ");
  checkEq(&container, &c, "wwune", "ㄉㄧㄥˊ");
  checkEq(&container, &c, "wwunr", "ㄉㄧㄥˇ");
  checkEq(&container, &c, "wwund", "ㄉㄧㄥˋ");
  checkEq(&container, &c, "wwj", "ㄉㄨ");
  checkEq(&container, &c, "wwje", "ㄉㄨˊ");
  checkEq(&container, &c, "wwjr", "ㄉㄨˇ");
  checkEq(&container, &c, "wwjd", "ㄉㄨˋ");
  checkEq(&container, &c, "wwji", "ㄉㄨㄛ");
  checkEq(&container, &c, "wwjie", "ㄉㄨㄛˊ");
  checkEq(&container, &c, "wwjir", "ㄉㄨㄛˇ");
  checkEq(&container, &c, "wwjid", "ㄉㄨㄛˋ");
  checkEq(&container, &c, "wwjiy", "ㄉㄨㄛ˙");
  checkEq(&container, &c, "wwjo", "ㄉㄨㄟ");
  checkEq(&container, &c, "wwjor", "ㄉㄨㄟˇ");
  checkEq(&container, &c, "wwjod", "ㄉㄨㄟˋ");
  checkEq(&container, &c, "wwjoo", "ㄉㄨㄢ");
  checkEq(&container, &c, "wwjoor", "ㄉㄨㄢˇ");
  checkEq(&container, &c, "wwjood", "ㄉㄨㄢˋ");
  checkEq(&container, &c, "wwjp", "ㄉㄨㄣ");
  checkEq(&container, &c, "wwjpr", "ㄉㄨㄣˇ");
  checkEq(&container, &c, "wwjpd", "ㄉㄨㄣˋ");
  checkEq(&container, &c, "wwjn", "ㄉㄨㄥ");
  checkEq(&container, &c, "wwjnr", "ㄉㄨㄥˇ");
  checkEq(&container, &c, "wwjnd", "ㄉㄨㄥˋ");
  checkEq(&container, &c, "wuu", "ㄊㄚ");
  checkEq(&container, &c, "wuur", "ㄊㄚˇ");
  checkEq(&container, &c, "wuud", "ㄊㄚˋ");
  checkEq(&container, &c, "wkd", "ㄊㄜˋ");
  checkEq(&container, &c, "wii", "ㄊㄞ");
  checkEq(&container, &c, "wiie", "ㄊㄞˊ");
  checkEq(&container, &c, "wiir", "ㄊㄞˇ");
  checkEq(&container, &c, "wiid", "ㄊㄞˋ");
  checkEq(&container, &c, "wiiy", "ㄊㄞ˙");
  checkEq(&container, &c, "wl", "ㄊㄠ");
  checkEq(&container, &c, "wle", "ㄊㄠˊ");
  checkEq(&container, &c, "wlr", "ㄊㄠˇ");
  checkEq(&container, &c, "wld", "ㄊㄠˋ");
  checkEq(&container, &c, "wly", "ㄊㄠ˙");
  checkEq(&container, &c, "wm", "ㄊㄡ");
  checkEq(&container, &c, "wme", "ㄊㄡˊ");
  checkEq(&container, &c, "wmr", "ㄊㄡˇ");
  checkEq(&container, &c, "wmd", "ㄊㄡˋ");
  checkEq(&container, &c, "wmy", "ㄊㄡ˙");
  checkEq(&container, &c, "woo", "ㄊㄢ");
  checkEq(&container, &c, "wooe", "ㄊㄢˊ");
  checkEq(&container, &c, "woor", "ㄊㄢˇ");
  checkEq(&container, &c, "wood", "ㄊㄢˋ");
  checkEq(&container, &c, "wll", "ㄊㄤ");
  checkEq(&container, &c, "wlle", "ㄊㄤˊ");
  checkEq(&container, &c, "wllr", "ㄊㄤˇ");
  checkEq(&container, &c, "wlld", "ㄊㄤˋ");
  checkEq(&container, &c, "wn", "ㄊㄥ");
  checkEq(&container, &c, "wne", "ㄊㄥˊ");
  checkEq(&container, &c, "wnd", "ㄊㄥˋ");
  checkEq(&container, &c, "wu", "ㄊㄧ");
  checkEq(&container, &c, "wue", "ㄊㄧˊ");
  checkEq(&container, &c, "wur", "ㄊㄧˇ");
  checkEq(&container, &c, "wud", "ㄊㄧˋ");
  checkEq(&container, &c, "wub", "ㄊㄧㄝ");
  checkEq(&container, &c, "wube", "ㄊㄧㄝˊ");
  checkEq(&container, &c, "wubr", "ㄊㄧㄝˇ");
  checkEq(&container, &c, "wubd", "ㄊㄧㄝˋ");
  checkEq(&container, &c, "wul", "ㄊㄧㄠ");
  checkEq(&container, &c, "wule", "ㄊㄧㄠˊ");
  checkEq(&container, &c, "wulr", "ㄊㄧㄠˇ");
  checkEq(&container, &c, "wuld", "ㄊㄧㄠˋ");
  checkEq(&container, &c, "wuoo", "ㄊㄧㄢ");
  checkEq(&container, &c, "wuooe", "ㄊㄧㄢˊ");
  checkEq(&container, &c, "wuoor", "ㄊㄧㄢˇ");
  checkEq(&container, &c, "wuood", "ㄊㄧㄢˋ");
  checkEq(&container, &c, "wun", "ㄊㄧㄥ");
  checkEq(&container, &c, "wune", "ㄊㄧㄥˊ");
  checkEq(&container, &c, "wunr", "ㄊㄧㄥˇ");
  checkEq(&container, &c, "wund", "ㄊㄧㄥˋ");
  checkEq(&container, &c, "wj", "ㄊㄨ");
  checkEq(&container, &c, "wje", "ㄊㄨˊ");
  checkEq(&container, &c, "wjr", "ㄊㄨˇ");
  checkEq(&container, &c, "wjd", "ㄊㄨˋ");
  checkEq(&container, &c, "wji", "ㄊㄨㄛ");
  checkEq(&container, &c, "wjie", "ㄊㄨㄛˊ");
  checkEq(&container, &c, "wjir", "ㄊㄨㄛˇ");
  checkEq(&container, &c, "wjid", "ㄊㄨㄛˋ");
  checkEq(&container, &c, "wjo", "ㄊㄨㄟ");
  checkEq(&container, &c, "wjoe", "ㄊㄨㄟˊ");
  checkEq(&container, &c, "wjor", "ㄊㄨㄟˇ");
  checkEq(&container, &c, "wjod", "ㄊㄨㄟˋ");
  checkEq(&container, &c, "wjoo", "ㄊㄨㄢ");
  checkEq(&container, &c, "wjooe", "ㄊㄨㄢˊ");
  checkEq(&container, &c, "wjoor", "ㄊㄨㄢˇ");
  checkEq(&container, &c, "wjood", "ㄊㄨㄢˋ");
  checkEq(&container, &c, "wjp", "ㄊㄨㄣ");
  checkEq(&container, &c, "wjpe", "ㄊㄨㄣˊ");
  checkEq(&container, &c, "wjpr", "ㄊㄨㄣˇ");
  checkEq(&container, &c, "wjpd", "ㄊㄨㄣˋ");
  checkEq(&container, &c, "wjn", "ㄊㄨㄥ");
  checkEq(&container, &c, "wjne", "ㄊㄨㄥˊ");
  checkEq(&container, &c, "wjnr", "ㄊㄨㄥˇ");
  checkEq(&container, &c, "wjnd", "ㄊㄨㄥˋ");
  checkEq(&container, &c, "suu", "ㄋㄚ");
  checkEq(&container, &c, "suue", "ㄋㄚˊ");
  checkEq(&container, &c, "suur", "ㄋㄚˇ");
  checkEq(&container, &c, "suud", "ㄋㄚˋ");
  checkEq(&container, &c, "suuy", "ㄋㄚ˙");
  checkEq(&container, &c, "skd", "ㄋㄜˋ");
  checkEq(&container, &c, "sky", "ㄋㄜ˙");
  checkEq(&container, &c, "siie", "ㄋㄞˊ");
  checkEq(&container, &c, "siir", "ㄋㄞˇ");
  checkEq(&container, &c, "siid", "ㄋㄞˋ");
  checkEq(&container, &c, "soe", "ㄋㄟˊ");
  checkEq(&container, &c, "sor", "ㄋㄟˇ");
  checkEq(&container, &c, "sod", "ㄋㄟˋ");
  checkEq(&container, &c, "sl", "ㄋㄠ");
  checkEq(&container, &c, "sle", "ㄋㄠˊ");
  checkEq(&container, &c, "slr", "ㄋㄠˇ");
  checkEq(&container, &c, "sld", "ㄋㄠˋ");
  checkEq(&container, &c, "sme", "ㄋㄡˊ");
  checkEq(&container, &c, "smr", "ㄋㄡˇ");
  checkEq(&container, &c, "smd", "ㄋㄡˋ");
  checkEq(&container, &c, "soo", "ㄋㄢ");
  checkEq(&container, &c, "sooe", "ㄋㄢˊ");
  checkEq(&container, &c, "soor", "ㄋㄢˇ");
  checkEq(&container, &c, "sood", "ㄋㄢˋ");
  checkEq(&container, &c, "spr", "ㄋㄣˇ");
  checkEq(&container, &c, "spd", "ㄋㄣˋ");
  checkEq(&container, &c, "sll", "ㄋㄤ");
  checkEq(&container, &c, "slle", "ㄋㄤˊ");
  checkEq(&container, &c, "sllr", "ㄋㄤˇ");
  checkEq(&container, &c, "slld", "ㄋㄤˋ");
  checkEq(&container, &c, "slly", "ㄋㄤ˙");
  checkEq(&container, &c, "sne", "ㄋㄥˊ");
  checkEq(&container, &c, "snr", "ㄋㄥˇ");
  checkEq(&container, &c, "su", "ㄋㄧ");
  checkEq(&container, &c, "sue", "ㄋㄧˊ");
  checkEq(&container, &c, "sur", "ㄋㄧˇ");
  checkEq(&container, &c, "sud", "ㄋㄧˋ");
  checkEq(&container, &c, "sub", "ㄋㄧㄝ");
  checkEq(&container, &c, "sube", "ㄋㄧㄝˊ");
  checkEq(&container, &c, "subd", "ㄋㄧㄝˋ");
  checkEq(&container, &c, "sulr", "ㄋㄧㄠˇ");
  checkEq(&container, &c, "suld", "ㄋㄧㄠˋ");
  checkEq(&container, &c, "sum", "ㄋㄧㄡ");
  checkEq(&container, &c, "sume", "ㄋㄧㄡˊ");
  checkEq(&container, &c, "sumr", "ㄋㄧㄡˇ");
  checkEq(&container, &c, "sumd", "ㄋㄧㄡˋ");
  checkEq(&container, &c, "suoo", "ㄋㄧㄢ");
  checkEq(&container, &c, "suooe", "ㄋㄧㄢˊ");
  checkEq(&container, &c, "suoor", "ㄋㄧㄢˇ");
  checkEq(&container, &c, "suood", "ㄋㄧㄢˋ");
  checkEq(&container, &c, "sup", "ㄋㄧㄣ");
  checkEq(&container, &c, "supe", "ㄋㄧㄣˊ");
  checkEq(&container, &c, "supr", "ㄋㄧㄣˇ");
  checkEq(&container, &c, "supd", "ㄋㄧㄣˋ");
  checkEq(&container, &c, "sulle", "ㄋㄧㄤˊ");
  checkEq(&container, &c, "sullr", "ㄋㄧㄤˇ");
  checkEq(&container, &c, "sulld", "ㄋㄧㄤˋ");
  checkEq(&container, &c, "sune", "ㄋㄧㄥˊ");
  checkEq(&container, &c, "sunr", "ㄋㄧㄥˇ");
  checkEq(&container, &c, "sund", "ㄋㄧㄥˋ");
  checkEq(&container, &c, "sje", "ㄋㄨˊ");
  checkEq(&container, &c, "sjr", "ㄋㄨˇ");
  checkEq(&container, &c, "sjd", "ㄋㄨˋ");
  checkEq(&container, &c, "sjie", "ㄋㄨㄛˊ");
  checkEq(&container, &c, "sjir", "ㄋㄨㄛˇ");
  checkEq(&container, &c, "sjid", "ㄋㄨㄛˋ");
  checkEq(&container, &c, "sjoe", "ㄋㄨㄟˊ");
  checkEq(&container, &c, "sjooe", "ㄋㄨㄢˊ");
  checkEq(&container, &c, "sjoor", "ㄋㄨㄢˇ");
  checkEq(&container, &c, "sjood", "ㄋㄨㄢˋ");
  checkEq(&container, &c, "sjpe", "ㄋㄨㄣˊ");
  checkEq(&container, &c, "sjne", "ㄋㄨㄥˊ");
  checkEq(&container, &c, "sjnr", "ㄋㄨㄥˇ");
  checkEq(&container, &c, "sjnd", "ㄋㄨㄥˋ");
  checkEq(&container, &c, "smme", "ㄋㄩˊ");
  checkEq(&container, &c, "smmr", "ㄋㄩˇ");
  checkEq(&container, &c, "smmd", "ㄋㄩˋ");
  checkEq(&container, &c, "smmbd", "ㄋㄩㄝˋ");
  checkEq(&container, &c, "xuu", "ㄌㄚ");
  checkEq(&container, &c, "xuue", "ㄌㄚˊ");
  checkEq(&container, &c, "xuur", "ㄌㄚˇ");
  checkEq(&container, &c, "xuud", "ㄌㄚˋ");
  checkEq(&container, &c, "xuuy", "ㄌㄚ˙");
  checkEq(&container, &c, "xi", "ㄌㄛ");
  checkEq(&container, &c, "xiy", "ㄌㄛ˙");
  checkEq(&container, &c, "xk", "ㄌㄜ");
  checkEq(&container, &c, "xke", "ㄌㄜˊ");
  checkEq(&container, &c, "xkd", "ㄌㄜˋ");
  checkEq(&container, &c, "xky", "ㄌㄜ˙");
  checkEq(&container, &c, "xiie", "ㄌㄞˊ");
  checkEq(&container, &c, "xiir", "ㄌㄞˇ");
  checkEq(&container, &c, "xiid", "ㄌㄞˋ");
  checkEq(&container, &c, "xo", "ㄌㄟ");
  checkEq(&container, &c, "xoe", "ㄌㄟˊ");
  checkEq(&container, &c, "xor", "ㄌㄟˇ");
  checkEq(&container, &c, "xod", "ㄌㄟˋ");
  checkEq(&container, &c, "xoy", "ㄌㄟ˙");
  checkEq(&container, &c, "xl", "ㄌㄠ");
  checkEq(&container, &c, "xle", "ㄌㄠˊ");
  checkEq(&container, &c, "xlr", "ㄌㄠˇ");
  checkEq(&container, &c, "xld", "ㄌㄠˋ");
  checkEq(&container, &c, "xm", "ㄌㄡ");
  checkEq(&container, &c, "xme", "ㄌㄡˊ");
  checkEq(&container, &c, "xmr", "ㄌㄡˇ");
  checkEq(&container, &c, "xmd", "ㄌㄡˋ");
  checkEq(&container, &c, "xmy", "ㄌㄡ˙");
  checkEq(&container, &c, "xooe", "ㄌㄢˊ");
  checkEq(&container, &c, "xoor", "ㄌㄢˇ");
  checkEq(&container, &c, "xood", "ㄌㄢˋ");
  checkEq(&container, &c, "xll", "ㄌㄤ");
  checkEq(&container, &c, "xlle", "ㄌㄤˊ");
  checkEq(&container, &c, "xllr", "ㄌㄤˇ");
  checkEq(&container, &c, "xlld", "ㄌㄤˋ");
  checkEq(&container, &c, "xn", "ㄌㄥ");
  checkEq(&container, &c, "xne", "ㄌㄥˊ");
  checkEq(&container, &c, "xnr", "ㄌㄥˇ");
  checkEq(&container, &c, "xnd", "ㄌㄥˋ");
  checkEq(&container, &c, "xu", "ㄌㄧ");
  checkEq(&container, &c, "xue", "ㄌㄧˊ");
  checkEq(&container, &c, "xur", "ㄌㄧˇ");
  checkEq(&container, &c, "xud", "ㄌㄧˋ");
  checkEq(&container, &c, "xuy", "ㄌㄧ˙");
  checkEq(&container, &c, "xuuur", "ㄌㄧㄚˇ");
  checkEq(&container, &c, "xub", "ㄌㄧㄝ");
  checkEq(&container, &c, "xube", "ㄌㄧㄝˊ");
  checkEq(&container, &c, "xubr", "ㄌㄧㄝˇ");
  checkEq(&container, &c, "xubd", "ㄌㄧㄝˋ");
  checkEq(&container, &c, "xul", "ㄌㄧㄠ");
  checkEq(&container, &c, "xule", "ㄌㄧㄠˊ");
  checkEq(&container, &c, "xulr", "ㄌㄧㄠˇ");
  checkEq(&container, &c, "xuld", "ㄌㄧㄠˋ");
  checkEq(&container, &c, "xum", "ㄌㄧㄡ");
  checkEq(&container, &c, "xume", "ㄌㄧㄡˊ");
  checkEq(&container, &c, "xumr", "ㄌㄧㄡˇ");
  checkEq(&container, &c, "xumd", "ㄌㄧㄡˋ");
  checkEq(&container, &c, "xuoo", "ㄌㄧㄢ");
  checkEq(&container, &c, "xuooe", "ㄌㄧㄢˊ");
  checkEq(&container, &c, "xuoor", "ㄌㄧㄢˇ");
  checkEq(&container, &c, "xuood", "ㄌㄧㄢˋ");
  checkEq(&container, &c, "xupe", "ㄌㄧㄣˊ");
  checkEq(&container, &c, "xupr", "ㄌㄧㄣˇ");
  checkEq(&container, &c, "xupd", "ㄌㄧㄣˋ");
  checkEq(&container, &c, "xulle", "ㄌㄧㄤˊ");
  checkEq(&container, &c, "xullr", "ㄌㄧㄤˇ");
  checkEq(&container, &c, "xulld", "ㄌㄧㄤˋ");
  checkEq(&container, &c, "xun", "ㄌㄧㄥ");
  checkEq(&container, &c, "xune", "ㄌㄧㄥˊ");
  checkEq(&container, &c, "xunr", "ㄌㄧㄥˇ");
  checkEq(&container, &c, "xund", "ㄌㄧㄥˋ");
  checkEq(&container, &c, "xj", "ㄌㄨ");
  checkEq(&container, &c, "xje", "ㄌㄨˊ");
  checkEq(&container, &c, "xjr", "ㄌㄨˇ");
  checkEq(&container, &c, "xjd", "ㄌㄨˋ");
  checkEq(&container, &c, "xji", "ㄌㄨㄛ");
  checkEq(&container, &c, "xjie", "ㄌㄨㄛˊ");
  checkEq(&container, &c, "xjir", "ㄌㄨㄛˇ");
  checkEq(&container, &c, "xjid", "ㄌㄨㄛˋ");
  checkEq(&container, &c, "xjiy", "ㄌㄨㄛ˙");
  checkEq(&container, &c, "xjooe", "ㄌㄨㄢˊ");
  checkEq(&container, &c, "xjoor", "ㄌㄨㄢˇ");
  checkEq(&container, &c, "xjood", "ㄌㄨㄢˋ");
  checkEq(&container, &c, "xjp", "ㄌㄨㄣ");
  checkEq(&container, &c, "xjpe", "ㄌㄨㄣˊ");
  checkEq(&container, &c, "xjpr", "ㄌㄨㄣˇ");
  checkEq(&container, &c, "xjpd", "ㄌㄨㄣˋ");
  checkEq(&container, &c, "xjn", "ㄌㄨㄥ");
  checkEq(&container, &c, "xjne", "ㄌㄨㄥˊ");
  checkEq(&container, &c, "xjnr", "ㄌㄨㄥˇ");
  checkEq(&container, &c, "xjnd", "ㄌㄨㄥˋ");
  checkEq(&container, &c, "xmm", "ㄌㄩ");
  checkEq(&container, &c, "xmme", "ㄌㄩˊ");
  checkEq(&container, &c, "xmmr", "ㄌㄩˇ");
  checkEq(&container, &c, "xmmd", "ㄌㄩˋ");
  checkEq(&container, &c, "xmmb", "ㄌㄩㄝ");
  checkEq(&container, &c, "xmmbr", "ㄌㄩㄝˇ");
  checkEq(&container, &c, "xmmbd", "ㄌㄩㄝˋ");
  checkEq(&container, &c, "xmmooe", "ㄌㄩㄢˊ");
  checkEq(&container, &c, "xmmoor", "ㄌㄩㄢˇ");
  checkEq(&container, &c, "euu", "ㄍㄚ");
  checkEq(&container, &c, "euue", "ㄍㄚˊ");
  checkEq(&container, &c, "euur", "ㄍㄚˇ");
  checkEq(&container, &c, "euud", "ㄍㄚˋ");
  checkEq(&container, &c, "euuy", "ㄍㄚ˙");
  checkEq(&container, &c, "ek", "ㄍㄜ");
  checkEq(&container, &c, "eke", "ㄍㄜˊ");
  checkEq(&container, &c, "ekr", "ㄍㄜˇ");
  checkEq(&container, &c, "ekd", "ㄍㄜˋ");
  checkEq(&container, &c, "eky", "ㄍㄜ˙");
  checkEq(&container, &c, "eii", "ㄍㄞ");
  checkEq(&container, &c, "eiir", "ㄍㄞˇ");
  checkEq(&container, &c, "eiid", "ㄍㄞˋ");
  checkEq(&container, &c, "eor", "ㄍㄟˇ");
  checkEq(&container, &c, "el", "ㄍㄠ");
  checkEq(&container, &c, "elr", "ㄍㄠˇ");
  checkEq(&container, &c, "eld", "ㄍㄠˋ");
  checkEq(&container, &c, "em", "ㄍㄡ");
  checkEq(&container, &c, "emr", "ㄍㄡˇ");
  checkEq(&container, &c, "emd", "ㄍㄡˋ");
  checkEq(&container, &c, "eoo", "ㄍㄢ");
  checkEq(&container, &c, "eoor", "ㄍㄢˇ");
  checkEq(&container, &c, "eood", "ㄍㄢˋ");
  checkEq(&container, &c, "ep", "ㄍㄣ");
  checkEq(&container, &c, "epe", "ㄍㄣˊ");
  checkEq(&container, &c, "epr", "ㄍㄣˇ");
  checkEq(&container, &c, "epd", "ㄍㄣˋ");
  checkEq(&container, &c, "ell", "ㄍㄤ");
  checkEq(&container, &c, "ellr", "ㄍㄤˇ");
  checkEq(&container, &c, "elld", "ㄍㄤˋ");
  checkEq(&container, &c, "en", "ㄍㄥ");
  checkEq(&container, &c, "enr", "ㄍㄥˇ");
  checkEq(&container, &c, "end", "ㄍㄥˋ");
  checkEq(&container, &c, "ej", "ㄍㄨ");
  checkEq(&container, &c, "eje", "ㄍㄨˊ");
  checkEq(&container, &c, "ejr", "ㄍㄨˇ");
  checkEq(&container, &c, "ejd", "ㄍㄨˋ");
  checkEq(&container, &c, "eju", "ㄍㄨㄚ");
  checkEq(&container, &c, "ejue", "ㄍㄨㄚˊ");
  checkEq(&container, &c, "ejur", "ㄍㄨㄚˇ");
  checkEq(&container, &c, "ejud", "ㄍㄨㄚˋ");
  checkEq(&container, &c, "eji", "ㄍㄨㄛ");
  checkEq(&container, &c, "ejie", "ㄍㄨㄛˊ");
  checkEq(&container, &c, "ejir", "ㄍㄨㄛˇ");
  checkEq(&container, &c, "ejid", "ㄍㄨㄛˋ");
  checkEq(&container, &c, "ejii", "ㄍㄨㄞ");
  checkEq(&container, &c, "ejiir", "ㄍㄨㄞˇ");
  checkEq(&container, &c, "ejiid", "ㄍㄨㄞˋ");
  checkEq(&container, &c, "ejo", "ㄍㄨㄟ");
  checkEq(&container, &c, "ejor", "ㄍㄨㄟˇ");
  checkEq(&container, &c, "ejod", "ㄍㄨㄟˋ");
  checkEq(&container, &c, "ejoo", "ㄍㄨㄢ");
  checkEq(&container, &c, "ejoor", "ㄍㄨㄢˇ");
  checkEq(&container, &c, "ejood", "ㄍㄨㄢˋ");
  checkEq(&container, &c, "ejp", "ㄍㄨㄣ");
  checkEq(&container, &c, "ejpr", "ㄍㄨㄣˇ");
  checkEq(&container, &c, "ejpd", "ㄍㄨㄣˋ");
  checkEq(&container, &c, "ejll", "ㄍㄨㄤ");
  checkEq(&container, &c, "ejllr", "ㄍㄨㄤˇ");
  checkEq(&container, &c, "ejlld", "ㄍㄨㄤˋ");
  checkEq(&container, &c, "ejn", "ㄍㄨㄥ");
  checkEq(&container, &c, "ejne", "ㄍㄨㄥˊ");
  checkEq(&container, &c, "ejnr", "ㄍㄨㄥˇ");
  checkEq(&container, &c, "ejnd", "ㄍㄨㄥˋ");
  checkEq(&container, &c, "duu", "ㄎㄚ");
  checkEq(&container, &c, "duur", "ㄎㄚˇ");
  checkEq(&container, &c, "duud", "ㄎㄚˋ");
  checkEq(&container, &c, "dk", "ㄎㄜ");
  checkEq(&container, &c, "dke", "ㄎㄜˊ");
  checkEq(&container, &c, "dkr", "ㄎㄜˇ");
  checkEq(&container, &c, "dkd", "ㄎㄜˋ");
  checkEq(&container, &c, "dii", "ㄎㄞ");
  checkEq(&container, &c, "diir", "ㄎㄞˇ");
  checkEq(&container, &c, "diid", "ㄎㄞˋ");
  checkEq(&container, &c, "dl", "ㄎㄠ");
  checkEq(&container, &c, "dlr", "ㄎㄠˇ");
  checkEq(&container, &c, "dld", "ㄎㄠˋ");
  checkEq(&container, &c, "dm", "ㄎㄡ");
  checkEq(&container, &c, "dmr", "ㄎㄡˇ");
  checkEq(&container, &c, "dmd", "ㄎㄡˋ");
  checkEq(&container, &c, "doo", "ㄎㄢ");
  checkEq(&container, &c, "door", "ㄎㄢˇ");
  checkEq(&container, &c, "dood", "ㄎㄢˋ");
  checkEq(&container, &c, "dp", "ㄎㄣ");
  checkEq(&container, &c, "dpr", "ㄎㄣˇ");
  checkEq(&container, &c, "dpd", "ㄎㄣˋ");
  checkEq(&container, &c, "dll", "ㄎㄤ");
  checkEq(&container, &c, "dlle", "ㄎㄤˊ");
  checkEq(&container, &c, "dllr", "ㄎㄤˇ");
  checkEq(&container, &c, "dlld", "ㄎㄤˋ");
  checkEq(&container, &c, "dn", "ㄎㄥ");
  checkEq(&container, &c, "dnr", "ㄎㄥˇ");
  checkEq(&container, &c, "dj", "ㄎㄨ");
  checkEq(&container, &c, "dje", "ㄎㄨˊ");
  checkEq(&container, &c, "djr", "ㄎㄨˇ");
  checkEq(&container, &c, "djd", "ㄎㄨˋ");
  checkEq(&container, &c, "dju", "ㄎㄨㄚ");
  checkEq(&container, &c, "djur", "ㄎㄨㄚˇ");
  checkEq(&container, &c, "djud", "ㄎㄨㄚˋ");
  checkEq(&container, &c, "djid", "ㄎㄨㄛˋ");
  checkEq(&container, &c, "djii", "ㄎㄨㄞ");
  checkEq(&container, &c, "djiir", "ㄎㄨㄞˇ");
  checkEq(&container, &c, "djiid", "ㄎㄨㄞˋ");
  checkEq(&container, &c, "djo", "ㄎㄨㄟ");
  checkEq(&container, &c, "djoe", "ㄎㄨㄟˊ");
  checkEq(&container, &c, "djor", "ㄎㄨㄟˇ");
  checkEq(&container, &c, "djod", "ㄎㄨㄟˋ");
  checkEq(&container, &c, "djoo", "ㄎㄨㄢ");
  checkEq(&container, &c, "djoor", "ㄎㄨㄢˇ");
  checkEq(&container, &c, "djood", "ㄎㄨㄢˋ");
  checkEq(&container, &c, "djp", "ㄎㄨㄣ");
  checkEq(&container, &c, "djpr", "ㄎㄨㄣˇ");
  checkEq(&container, &c, "djpd", "ㄎㄨㄣˋ");
  checkEq(&container, &c, "djll", "ㄎㄨㄤ");
  checkEq(&container, &c, "djlle", "ㄎㄨㄤˊ");
  checkEq(&container, &c, "djllr", "ㄎㄨㄤˇ");
  checkEq(&container, &c, "djlld", "ㄎㄨㄤˋ");
  checkEq(&container, &c, "djn", "ㄎㄨㄥ");
  checkEq(&container, &c, "djnr", "ㄎㄨㄥˇ");
  checkEq(&container, &c, "djnd", "ㄎㄨㄥˋ");
  checkEq(&container, &c, "cuu", "ㄏㄚ");
  checkEq(&container, &c, "cuue", "ㄏㄚˊ");
  checkEq(&container, &c, "cuur", "ㄏㄚˇ");
  checkEq(&container, &c, "ck", "ㄏㄜ");
  checkEq(&container, &c, "cke", "ㄏㄜˊ");
  checkEq(&container, &c, "ckr", "ㄏㄜˇ");
  checkEq(&container, &c, "ckd", "ㄏㄜˋ");
  checkEq(&container, &c, "cii", "ㄏㄞ");
  checkEq(&container, &c, "ciie", "ㄏㄞˊ");
  checkEq(&container, &c, "ciir", "ㄏㄞˇ");
  checkEq(&container, &c, "ciid", "ㄏㄞˋ");
  checkEq(&container, &c, "co", "ㄏㄟ");
  checkEq(&container, &c, "cor", "ㄏㄟˇ");
  checkEq(&container, &c, "cl", "ㄏㄠ");
  checkEq(&container, &c, "cle", "ㄏㄠˊ");
  checkEq(&container, &c, "clr", "ㄏㄠˇ");
  checkEq(&container, &c, "cld", "ㄏㄠˋ");
  checkEq(&container, &c, "cm", "ㄏㄡ");
  checkEq(&container, &c, "cme", "ㄏㄡˊ");
  checkEq(&container, &c, "cmr", "ㄏㄡˇ");
  checkEq(&container, &c, "cmd", "ㄏㄡˋ");
  checkEq(&container, &c, "coo", "ㄏㄢ");
  checkEq(&container, &c, "cooe", "ㄏㄢˊ");
  checkEq(&container, &c, "coor", "ㄏㄢˇ");
  checkEq(&container, &c, "cood", "ㄏㄢˋ");
  checkEq(&container, &c, "cp", "ㄏㄣ");
  checkEq(&container, &c, "cpe", "ㄏㄣˊ");
  checkEq(&container, &c, "cpr", "ㄏㄣˇ");
  checkEq(&container, &c, "cpd", "ㄏㄣˋ");
  checkEq(&container, &c, "cll", "ㄏㄤ");
  checkEq(&container, &c, "clle", "ㄏㄤˊ");
  checkEq(&container, &c, "cllr", "ㄏㄤˇ");
  checkEq(&container, &c, "clld", "ㄏㄤˋ");
  checkEq(&container, &c, "cn", "ㄏㄥ");
  checkEq(&container, &c, "cne", "ㄏㄥˊ");
  checkEq(&container, &c, "cnd", "ㄏㄥˋ");
  checkEq(&container, &c, "cj", "ㄏㄨ");
  checkEq(&container, &c, "cje", "ㄏㄨˊ");
  checkEq(&container, &c, "cjr", "ㄏㄨˇ");
  checkEq(&container, &c, "cjd", "ㄏㄨˋ");
  checkEq(&container, &c, "cju", "ㄏㄨㄚ");
  checkEq(&container, &c, "cjue", "ㄏㄨㄚˊ");
  checkEq(&container, &c, "cjur", "ㄏㄨㄚˇ");
  checkEq(&container, &c, "cjud", "ㄏㄨㄚˋ");
  checkEq(&container, &c, "cji", "ㄏㄨㄛ");
  checkEq(&container, &c, "cjie", "ㄏㄨㄛˊ");
  checkEq(&container, &c, "cjir", "ㄏㄨㄛˇ");
  checkEq(&container, &c, "cjid", "ㄏㄨㄛˋ");
  checkEq(&container, &c, "cjiy", "ㄏㄨㄛ˙");
  checkEq(&container, &c, "cjiie", "ㄏㄨㄞˊ");
  checkEq(&container, &c, "cjiid", "ㄏㄨㄞˋ");
  checkEq(&container, &c, "cjo", "ㄏㄨㄟ");
  checkEq(&container, &c, "cjoe", "ㄏㄨㄟˊ");
  checkEq(&container, &c, "cjor", "ㄏㄨㄟˇ");
  checkEq(&container, &c, "cjod", "ㄏㄨㄟˋ");
  checkEq(&container, &c, "cjoo", "ㄏㄨㄢ");
  checkEq(&container, &c, "cjooe", "ㄏㄨㄢˊ");
  checkEq(&container, &c, "cjoor", "ㄏㄨㄢˇ");
  checkEq(&container, &c, "cjood", "ㄏㄨㄢˋ");
  checkEq(&container, &c, "cjp", "ㄏㄨㄣ");
  checkEq(&container, &c, "cjpe", "ㄏㄨㄣˊ");
  checkEq(&container, &c, "cjpr", "ㄏㄨㄣˇ");
  checkEq(&container, &c, "cjpd", "ㄏㄨㄣˋ");
  checkEq(&container, &c, "cjll", "ㄏㄨㄤ");
  checkEq(&container, &c, "cjlle", "ㄏㄨㄤˊ");
  checkEq(&container, &c, "cjllr", "ㄏㄨㄤˇ");
  checkEq(&container, &c, "cjlld", "ㄏㄨㄤˋ");
  checkEq(&container, &c, "cjlly", "ㄏㄨㄤ˙");
  checkEq(&container, &c, "cjn", "ㄏㄨㄥ");
  checkEq(&container, &c, "cjne", "ㄏㄨㄥˊ");
  checkEq(&container, &c, "cjnr", "ㄏㄨㄥˇ");
  checkEq(&container, &c, "cjnd", "ㄏㄨㄥˋ");
  checkEq(&container, &c, "ru", "ㄐㄧ");
  checkEq(&container, &c, "rue", "ㄐㄧˊ");
  checkEq(&container, &c, "rur", "ㄐㄧˇ");
  checkEq(&container, &c, "rud", "ㄐㄧˋ");
  checkEq(&container, &c, "ruuu", "ㄐㄧㄚ");
  checkEq(&container, &c, "ruuue", "ㄐㄧㄚˊ");
  checkEq(&container, &c, "ruuur", "ㄐㄧㄚˇ");
  checkEq(&container, &c, "ruuud", "ㄐㄧㄚˋ");
  checkEq(&container, &c, "rub", "ㄐㄧㄝ");
  checkEq(&container, &c, "rube", "ㄐㄧㄝˊ");
  checkEq(&container, &c, "rubr", "ㄐㄧㄝˇ");
  checkEq(&container, &c, "rubd", "ㄐㄧㄝˋ");
  checkEq(&container, &c, "ruby", "ㄐㄧㄝ˙");
  checkEq(&container, &c, "rul", "ㄐㄧㄠ");
  checkEq(&container, &c, "rule", "ㄐㄧㄠˊ");
  checkEq(&container, &c, "rulr", "ㄐㄧㄠˇ");
  checkEq(&container, &c, "ruld", "ㄐㄧㄠˋ");
  checkEq(&container, &c, "rum", "ㄐㄧㄡ");
  checkEq(&container, &c, "rumr", "ㄐㄧㄡˇ");
  checkEq(&container, &c, "rumd", "ㄐㄧㄡˋ");
  checkEq(&container, &c, "ruoo", "ㄐㄧㄢ");
  checkEq(&container, &c, "ruoor", "ㄐㄧㄢˇ");
  checkEq(&container, &c, "ruood", "ㄐㄧㄢˋ");
  checkEq(&container, &c, "rup", "ㄐㄧㄣ");
  checkEq(&container, &c, "rupr", "ㄐㄧㄣˇ");
  checkEq(&container, &c, "rupd", "ㄐㄧㄣˋ");
  checkEq(&container, &c, "rull", "ㄐㄧㄤ");
  checkEq(&container, &c, "rulle", "ㄐㄧㄤˊ");
  checkEq(&container, &c, "rullr", "ㄐㄧㄤˇ");
  checkEq(&container, &c, "rulld", "ㄐㄧㄤˋ");
  checkEq(&container, &c, "run", "ㄐㄧㄥ");
  checkEq(&container, &c, "runr", "ㄐㄧㄥˇ");
  checkEq(&container, &c, "rund", "ㄐㄧㄥˋ");
  checkEq(&container, &c, "rm", "ㄐㄩ");
  checkEq(&container, &c, "rme", "ㄐㄩˊ");
  checkEq(&container, &c, "rmr", "ㄐㄩˇ");
  checkEq(&container, &c, "rmd", "ㄐㄩˋ");
  checkEq(&container, &c, "rmb", "ㄐㄩㄝ");
  checkEq(&container, &c, "rmbe", "ㄐㄩㄝˊ");
  checkEq(&container, &c, "rmbr", "ㄐㄩㄝˇ");
  checkEq(&container, &c, "rmbd", "ㄐㄩㄝˋ");
  checkEq(&container, &c, "rmoo", "ㄐㄩㄢ");
  checkEq(&container, &c, "rmoor", "ㄐㄩㄢˇ");
  checkEq(&container, &c, "rmood", "ㄐㄩㄢˋ");
  checkEq(&container, &c, "rmp", "ㄐㄩㄣ");
  checkEq(&container, &c, "rmpe", "ㄐㄩㄣˊ");
  checkEq(&container, &c, "rmpr", "ㄐㄩㄣˇ");
  checkEq(&container, &c, "rmpd", "ㄐㄩㄣˋ");
  checkEq(&container, &c, "rmn", "ㄐㄩㄥ");
  checkEq(&container, &c, "rmnr", "ㄐㄩㄥˇ");
  checkEq(&container, &c, "rmnd", "ㄐㄩㄥˋ");
  checkEq(&container, &c, "fy", "ㄑ˙");
  checkEq(&container, &c, "fu", "ㄑㄧ");
  checkEq(&container, &c, "fue", "ㄑㄧˊ");
  checkEq(&container, &c, "fur", "ㄑㄧˇ");
  checkEq(&container, &c, "fud", "ㄑㄧˋ");
  checkEq(&container, &c, "fuuu", "ㄑㄧㄚ");
  checkEq(&container, &c, "fuuue", "ㄑㄧㄚˊ");
  checkEq(&container, &c, "fuuur", "ㄑㄧㄚˇ");
  checkEq(&container, &c, "fuuud", "ㄑㄧㄚˋ");
  checkEq(&container, &c, "fub", "ㄑㄧㄝ");
  checkEq(&container, &c, "fube", "ㄑㄧㄝˊ");
  checkEq(&container, &c, "fubr", "ㄑㄧㄝˇ");
  checkEq(&container, &c, "fubd", "ㄑㄧㄝˋ");
  checkEq(&container, &c, "ful", "ㄑㄧㄠ");
  checkEq(&container, &c, "fule", "ㄑㄧㄠˊ");
  checkEq(&container, &c, "fulr", "ㄑㄧㄠˇ");
  checkEq(&container, &c, "fuld", "ㄑㄧㄠˋ");
  checkEq(&container, &c, "fum", "ㄑㄧㄡ");
  checkEq(&container, &c, "fume", "ㄑㄧㄡˊ");
  checkEq(&container, &c, "fumr", "ㄑㄧㄡˇ");
  checkEq(&container, &c, "fumd", "ㄑㄧㄡˋ");
  checkEq(&container, &c, "fuoo", "ㄑㄧㄢ");
  checkEq(&container, &c, "fuooe", "ㄑㄧㄢˊ");
  checkEq(&container, &c, "fuoor", "ㄑㄧㄢˇ");
  checkEq(&container, &c, "fuood", "ㄑㄧㄢˋ");
  checkEq(&container, &c, "fup", "ㄑㄧㄣ");
  checkEq(&container, &c, "fupe", "ㄑㄧㄣˊ");
  checkEq(&container, &c, "fupr", "ㄑㄧㄣˇ");
  checkEq(&container, &c, "fupd", "ㄑㄧㄣˋ");
  checkEq(&container, &c, "full", "ㄑㄧㄤ");
  checkEq(&container, &c, "fulle", "ㄑㄧㄤˊ");
  checkEq(&container, &c, "fullr", "ㄑㄧㄤˇ");
  checkEq(&container, &c, "fulld", "ㄑㄧㄤˋ");
  checkEq(&container, &c, "fun", "ㄑㄧㄥ");
  checkEq(&container, &c, "fune", "ㄑㄧㄥˊ");
  checkEq(&container, &c, "funr", "ㄑㄧㄥˇ");
  checkEq(&container, &c, "fund", "ㄑㄧㄥˋ");
  checkEq(&container, &c, "fm", "ㄑㄩ");
  checkEq(&container, &c, "fme", "ㄑㄩˊ");
  checkEq(&container, &c, "fmr", "ㄑㄩˇ");
  checkEq(&container, &c, "fmd", "ㄑㄩˋ");
  checkEq(&container, &c, "fmb", "ㄑㄩㄝ");
  checkEq(&container, &c, "fmbe", "ㄑㄩㄝˊ");
  checkEq(&container, &c, "fmbd", "ㄑㄩㄝˋ");
  checkEq(&container, &c, "fmoo", "ㄑㄩㄢ");
  checkEq(&container, &c, "fmooe", "ㄑㄩㄢˊ");
  checkEq(&container, &c, "fmoor", "ㄑㄩㄢˇ");
  checkEq(&container, &c, "fmood", "ㄑㄩㄢˋ");
  checkEq(&container, &c, "fmp", "ㄑㄩㄣ");
  checkEq(&container, &c, "fmpe", "ㄑㄩㄣˊ");
  checkEq(&container, &c, "fmpr", "ㄑㄩㄣˇ");
  checkEq(&container, &c, "fmpd", "ㄑㄩㄣˋ");
  checkEq(&container, &c, "fmn", "ㄑㄩㄥ");
  checkEq(&container, &c, "fmne", "ㄑㄩㄥˊ");
  checkEq(&container, &c, "fmnr", "ㄑㄩㄥˇ");
  checkEq(&container, &c, "fmnd", "ㄑㄩㄥˋ");
  checkEq(&container, &c, "vu", "ㄒㄧ");
  checkEq(&container, &c, "vue", "ㄒㄧˊ");
  checkEq(&container, &c, "vur", "ㄒㄧˇ");
  checkEq(&container, &c, "vud", "ㄒㄧˋ");
  checkEq(&container, &c, "vuuu", "ㄒㄧㄚ");
  checkEq(&container, &c, "vuuue", "ㄒㄧㄚˊ");
  checkEq(&container, &c, "vuuur", "ㄒㄧㄚˇ");
  checkEq(&container, &c, "vuuud", "ㄒㄧㄚˋ");
  checkEq(&container, &c, "vub", "ㄒㄧㄝ");
  checkEq(&container, &c, "vube", "ㄒㄧㄝˊ");
  checkEq(&container, &c, "vubr", "ㄒㄧㄝˇ");
  checkEq(&container, &c, "vubd", "ㄒㄧㄝˋ");
  checkEq(&container, &c, "vul", "ㄒㄧㄠ");
  checkEq(&container, &c, "vule", "ㄒㄧㄠˊ");
  checkEq(&container, &c, "vulr", "ㄒㄧㄠˇ");
  checkEq(&container, &c, "vuld", "ㄒㄧㄠˋ");
  checkEq(&container, &c, "vum", "ㄒㄧㄡ");
  checkEq(&container, &c, "vume", "ㄒㄧㄡˊ");
  checkEq(&container, &c, "vumr", "ㄒㄧㄡˇ");
  checkEq(&container, &c, "vumd", "ㄒㄧㄡˋ");
  checkEq(&container, &c, "vuoo", "ㄒㄧㄢ");
  checkEq(&container, &c, "vuooe", "ㄒㄧㄢˊ");
  checkEq(&container, &c, "vuoor", "ㄒㄧㄢˇ");
  checkEq(&container, &c, "vuood", "ㄒㄧㄢˋ");
  checkEq(&container, &c, "vup", "ㄒㄧㄣ");
  checkEq(&container, &c, "vupe", "ㄒㄧㄣˊ");
  checkEq(&container, &c, "vupr", "ㄒㄧㄣˇ");
  checkEq(&container, &c, "vupd", "ㄒㄧㄣˋ");
  checkEq(&container, &c, "vull", "ㄒㄧㄤ");
  checkEq(&container, &c, "vulle", "ㄒㄧㄤˊ");
  checkEq(&container, &c, "vullr", "ㄒㄧㄤˇ");
  checkEq(&container, &c, "vulld", "ㄒㄧㄤˋ");
  checkEq(&container, &c, "vun", "ㄒㄧㄥ");
  checkEq(&container, &c, "vune", "ㄒㄧㄥˊ");
  checkEq(&container, &c, "vunr", "ㄒㄧㄥˇ");
  checkEq(&container, &c, "vund", "ㄒㄧㄥˋ");
  checkEq(&container, &c, "vm", "ㄒㄩ");
  checkEq(&container, &c, "vme", "ㄒㄩˊ");
  checkEq(&container, &c, "vmr", "ㄒㄩˇ");
  checkEq(&container, &c, "vmd", "ㄒㄩˋ");
  checkEq(&container, &c, "vmb", "ㄒㄩㄝ");
  checkEq(&container, &c, "vmbe", "ㄒㄩㄝˊ");
  checkEq(&container, &c, "vmbr", "ㄒㄩㄝˇ");
  checkEq(&container, &c, "vmbd", "ㄒㄩㄝˋ");
  checkEq(&container, &c, "vmoo", "ㄒㄩㄢ");
  checkEq(&container, &c, "vmooe", "ㄒㄩㄢˊ");
  checkEq(&container, &c, "vmoor", "ㄒㄩㄢˇ");
  checkEq(&container, &c, "vmood", "ㄒㄩㄢˋ");
  checkEq(&container, &c, "vmp", "ㄒㄩㄣ");
  checkEq(&container, &c, "vmpe", "ㄒㄩㄣˊ");
  checkEq(&container, &c, "vmpd", "ㄒㄩㄣˋ");
  checkEq(&container, &c, "vmn", "ㄒㄩㄥ");
  checkEq(&container, &c, "vmne", "ㄒㄩㄥˊ");
  checkEq(&container, &c, "vmnr", "ㄒㄩㄥˇ");
  checkEq(&container, &c, "vmnd", "ㄒㄩㄥˋ");
  checkEq(&container, &c, "tt", "ㄓ");
  checkEq(&container, &c, "tte", "ㄓˊ");
  checkEq(&container, &c, "ttr", "ㄓˇ");
  checkEq(&container, &c, "ttd", "ㄓˋ");
  checkEq(&container, &c, "ttuu", "ㄓㄚ");
  checkEq(&container, &c, "ttuue", "ㄓㄚˊ");
  checkEq(&container, &c, "ttuur", "ㄓㄚˇ");
  checkEq(&container, &c, "ttuud", "ㄓㄚˋ");
  checkEq(&container, &c, "ttk", "ㄓㄜ");
  checkEq(&container, &c, "ttke", "ㄓㄜˊ");
  checkEq(&container, &c, "ttkr", "ㄓㄜˇ");
  checkEq(&container, &c, "ttkd", "ㄓㄜˋ");
  checkEq(&container, &c, "ttky", "ㄓㄜ˙");
  checkEq(&container, &c, "ttii", "ㄓㄞ");
  checkEq(&container, &c, "ttiie", "ㄓㄞˊ");
  checkEq(&container, &c, "ttiir", "ㄓㄞˇ");
  checkEq(&container, &c, "ttiid", "ㄓㄞˋ");
  checkEq(&container, &c, "ttod", "ㄓㄟˋ");
  checkEq(&container, &c, "ttl", "ㄓㄠ");
  checkEq(&container, &c, "ttle", "ㄓㄠˊ");
  checkEq(&container, &c, "ttlr", "ㄓㄠˇ");
  checkEq(&container, &c, "ttld", "ㄓㄠˋ");
  checkEq(&container, &c, "ttm", "ㄓㄡ");
  checkEq(&container, &c, "ttme", "ㄓㄡˊ");
  checkEq(&container, &c, "ttmr", "ㄓㄡˇ");
  checkEq(&container, &c, "ttmd", "ㄓㄡˋ");
  checkEq(&container, &c, "ttoo", "ㄓㄢ");
  checkEq(&container, &c, "ttoor", "ㄓㄢˇ");
  checkEq(&container, &c, "ttood", "ㄓㄢˋ");
  checkEq(&container, &c, "ttp", "ㄓㄣ");
  checkEq(&container, &c, "ttpe", "ㄓㄣˊ");
  checkEq(&container, &c, "ttpr", "ㄓㄣˇ");
  checkEq(&container, &c, "ttpd", "ㄓㄣˋ");
  checkEq(&container, &c, "ttll", "ㄓㄤ");
  checkEq(&container, &c, "ttllr", "ㄓㄤˇ");
  checkEq(&container, &c, "ttlld", "ㄓㄤˋ");
  checkEq(&container, &c, "ttn", "ㄓㄥ");
  checkEq(&container, &c, "ttnr", "ㄓㄥˇ");
  checkEq(&container, &c, "ttnd", "ㄓㄥˋ");
  checkEq(&container, &c, "ttj", "ㄓㄨ");
  checkEq(&container, &c, "ttje", "ㄓㄨˊ");
  checkEq(&container, &c, "ttjr", "ㄓㄨˇ");
  checkEq(&container, &c, "ttjd", "ㄓㄨˋ");
  checkEq(&container, &c, "ttju", "ㄓㄨㄚ");
  checkEq(&container, &c, "ttjur", "ㄓㄨㄚˇ");
  checkEq(&container, &c, "ttji", "ㄓㄨㄛ");
  checkEq(&container, &c, "ttjie", "ㄓㄨㄛˊ");
  checkEq(&container, &c, "ttjid", "ㄓㄨㄛˋ");
  checkEq(&container, &c, "ttjii", "ㄓㄨㄞ");
  checkEq(&container, &c, "ttjiir", "ㄓㄨㄞˇ");
  checkEq(&container, &c, "ttjiid", "ㄓㄨㄞˋ");
  checkEq(&container, &c, "ttjo", "ㄓㄨㄟ");
  checkEq(&container, &c, "ttjor", "ㄓㄨㄟˇ");
  checkEq(&container, &c, "ttjod", "ㄓㄨㄟˋ");
  checkEq(&container, &c, "ttjoo", "ㄓㄨㄢ");
  checkEq(&container, &c, "ttjoor", "ㄓㄨㄢˇ");
  checkEq(&container, &c, "ttjood", "ㄓㄨㄢˋ");
  checkEq(&container, &c, "ttjp", "ㄓㄨㄣ");
  checkEq(&container, &c, "ttjpr", "ㄓㄨㄣˇ");
  checkEq(&container, &c, "ttjpd", "ㄓㄨㄣˋ");
  checkEq(&container, &c, "ttjll", "ㄓㄨㄤ");
  checkEq(&container, &c, "ttjllr", "ㄓㄨㄤˇ");
  checkEq(&container, &c, "ttjlld", "ㄓㄨㄤˋ");
  checkEq(&container, &c, "ttjn", "ㄓㄨㄥ");
  checkEq(&container, &c, "ttjnr", "ㄓㄨㄥˇ");
  checkEq(&container, &c, "ttjnd", "ㄓㄨㄥˋ");
  checkEq(&container, &c, "t ", "ㄔ ");
  checkEq(&container, &c, "te", "ㄔˊ");
  checkEq(&container, &c, "tr", "ㄔˇ");
  checkEq(&container, &c, "td", "ㄔˋ");
  checkEq(&container, &c, "tuu", "ㄔㄚ");
  checkEq(&container, &c, "tuue", "ㄔㄚˊ");
  checkEq(&container, &c, "tuur", "ㄔㄚˇ");
  checkEq(&container, &c, "tuud", "ㄔㄚˋ");
  checkEq(&container, &c, "tk ", "ㄔㄜ ");
  checkEq(&container, &c, "tkr", "ㄔㄜˇ");
  checkEq(&container, &c, "tkd", "ㄔㄜˋ");
  checkEq(&container, &c, "tii", "ㄔㄞ");
  checkEq(&container, &c, "tiie", "ㄔㄞˊ");
  checkEq(&container, &c, "tiir", "ㄔㄞˇ");
  checkEq(&container, &c, "tiid", "ㄔㄞˋ");
  checkEq(&container, &c, "tl", "ㄔㄠ");
  checkEq(&container, &c, "tle", "ㄔㄠˊ");
  checkEq(&container, &c, "tlr", "ㄔㄠˇ");
  checkEq(&container, &c, "tld", "ㄔㄠˋ");
  checkEq(&container, &c, "tm", "ㄔㄡ");
  checkEq(&container, &c, "tme", "ㄔㄡˊ");
  checkEq(&container, &c, "tmr", "ㄔㄡˇ");
  checkEq(&container, &c, "tmd", "ㄔㄡˋ");
  checkEq(&container, &c, "too ", "ㄔㄢ ");
  checkEq(&container, &c, "tooe", "ㄔㄢˊ");
  checkEq(&container, &c, "toor", "ㄔㄢˇ");
  checkEq(&container, &c, "tood", "ㄔㄢˋ");
  checkEq(&container, &c, "tp ", "ㄔㄣ ");
  checkEq(&container, &c, "tpe", "ㄔㄣˊ");
  checkEq(&container, &c, "tpr", "ㄔㄣˇ");
  checkEq(&container, &c, "tpd", "ㄔㄣˋ");
  checkEq(&container, &c, "tpy", "ㄔㄣ˙");
  checkEq(&container, &c, "tll ", "ㄔㄤ ");
  checkEq(&container, &c, "tlle", "ㄔㄤˊ");
  checkEq(&container, &c, "tllr", "ㄔㄤˇ");
  checkEq(&container, &c, "tlld", "ㄔㄤˋ");
  checkEq(&container, &c, "tn ", "ㄔㄥ ");
  checkEq(&container, &c, "tne", "ㄔㄥˊ");
  checkEq(&container, &c, "tnr", "ㄔㄥˇ");
  checkEq(&container, &c, "tnd", "ㄔㄥˋ");
  checkEq(&container, &c, "tj", "ㄔㄨ");
  checkEq(&container, &c, "tje", "ㄔㄨˊ");
  checkEq(&container, &c, "tjr", "ㄔㄨˇ");
  checkEq(&container, &c, "tjd", "ㄔㄨˋ");
  checkEq(&container, &c, "tju", "ㄔㄨㄚ");
  checkEq(&container, &c, "tjur", "ㄔㄨㄚˇ");
  checkEq(&container, &c, "tjud", "ㄔㄨㄚˋ");
  checkEq(&container, &c, "tji", "ㄔㄨㄛ");
  checkEq(&container, &c, "tjid", "ㄔㄨㄛˋ");
  checkEq(&container, &c, "tjii", "ㄔㄨㄞ");
  checkEq(&container, &c, "tjiie", "ㄔㄨㄞˊ");
  checkEq(&container, &c, "tjiir", "ㄔㄨㄞˇ");
  checkEq(&container, &c, "tjiid", "ㄔㄨㄞˋ");
  checkEq(&container, &c, "tjo", "ㄔㄨㄟ");
  checkEq(&container, &c, "tjoe", "ㄔㄨㄟˊ");
  checkEq(&container, &c, "tjor", "ㄔㄨㄟˇ");
  checkEq(&container, &c, "tjod", "ㄔㄨㄟˋ");
  checkEq(&container, &c, "tjoo", "ㄔㄨㄢ");
  checkEq(&container, &c, "tjooe", "ㄔㄨㄢˊ");
  checkEq(&container, &c, "tjoor", "ㄔㄨㄢˇ");
  checkEq(&container, &c, "tjood", "ㄔㄨㄢˋ");
  checkEq(&container, &c, "tjp", "ㄔㄨㄣ");
  checkEq(&container, &c, "tjpe", "ㄔㄨㄣˊ");
  checkEq(&container, &c, "tjpr", "ㄔㄨㄣˇ");
  checkEq(&container, &c, "tjll", "ㄔㄨㄤ");
  checkEq(&container, &c, "tjlle", "ㄔㄨㄤˊ");
  checkEq(&container, &c, "tjllr", "ㄔㄨㄤˇ");
  checkEq(&container, &c, "tjlld", "ㄔㄨㄤˋ");
  checkEq(&container, &c, "tjn", "ㄔㄨㄥ");
  checkEq(&container, &c, "tjne", "ㄔㄨㄥˊ");
  checkEq(&container, &c, "tjnr", "ㄔㄨㄥˇ");
  checkEq(&container, &c, "tjnd", "ㄔㄨㄥˋ");
  checkEq(&container, &c, "g", "ㄕ");
  checkEq(&container, &c, "ge", "ㄕˊ");
  checkEq(&container, &c, "gr", "ㄕˇ");
  checkEq(&container, &c, "gd", "ㄕˋ");
  checkEq(&container, &c, "gy", "ㄕ˙");
  checkEq(&container, &c, "guu", "ㄕㄚ");
  checkEq(&container, &c, "guue", "ㄕㄚˊ");
  checkEq(&container, &c, "guur", "ㄕㄚˇ");
  checkEq(&container, &c, "guud", "ㄕㄚˋ");
  checkEq(&container, &c, "guuy", "ㄕㄚ˙");
  checkEq(&container, &c, "gk", "ㄕㄜ");
  checkEq(&container, &c, "gke", "ㄕㄜˊ");
  checkEq(&container, &c, "gkr", "ㄕㄜˇ");
  checkEq(&container, &c, "gkd", "ㄕㄜˋ");
  checkEq(&container, &c, "gii", "ㄕㄞ");
  checkEq(&container, &c, "giir", "ㄕㄞˇ");
  checkEq(&container, &c, "giid", "ㄕㄞˋ");
  checkEq(&container, &c, "goe", "ㄕㄟˊ");
  checkEq(&container, &c, "gl", "ㄕㄠ");
  checkEq(&container, &c, "gle", "ㄕㄠˊ");
  checkEq(&container, &c, "glr", "ㄕㄠˇ");
  checkEq(&container, &c, "gld", "ㄕㄠˋ");
  checkEq(&container, &c, "gm", "ㄕㄡ");
  checkEq(&container, &c, "gme", "ㄕㄡˊ");
  checkEq(&container, &c, "gmr", "ㄕㄡˇ");
  checkEq(&container, &c, "gmd", "ㄕㄡˋ");
  checkEq(&container, &c, "goo", "ㄕㄢ");
  checkEq(&container, &c, "gooe", "ㄕㄢˊ");
  checkEq(&container, &c, "goor", "ㄕㄢˇ");
  checkEq(&container, &c, "good", "ㄕㄢˋ");
  checkEq(&container, &c, "gp", "ㄕㄣ");
  checkEq(&container, &c, "gpe", "ㄕㄣˊ");
  checkEq(&container, &c, "gpr", "ㄕㄣˇ");
  checkEq(&container, &c, "gpd", "ㄕㄣˋ");
  checkEq(&container, &c, "gll", "ㄕㄤ");
  checkEq(&container, &c, "gllr", "ㄕㄤˇ");
  checkEq(&container, &c, "glld", "ㄕㄤˋ");
  checkEq(&container, &c, "glly", "ㄕㄤ˙");
  checkEq(&container, &c, "gn", "ㄕㄥ");
  checkEq(&container, &c, "gne", "ㄕㄥˊ");
  checkEq(&container, &c, "gnr", "ㄕㄥˇ");
  checkEq(&container, &c, "gnd", "ㄕㄥˋ");
  checkEq(&container, &c, "gj", "ㄕㄨ");
  checkEq(&container, &c, "gje", "ㄕㄨˊ");
  checkEq(&container, &c, "gjr", "ㄕㄨˇ");
  checkEq(&container, &c, "gjd", "ㄕㄨˋ");
  checkEq(&container, &c, "gju", "ㄕㄨㄚ");
  checkEq(&container, &c, "gjur", "ㄕㄨㄚˇ");
  checkEq(&container, &c, "gjud", "ㄕㄨㄚˋ");
  checkEq(&container, &c, "gji", "ㄕㄨㄛ");
  checkEq(&container, &c, "gjid", "ㄕㄨㄛˋ");
  checkEq(&container, &c, "gjii", "ㄕㄨㄞ");
  checkEq(&container, &c, "gjiir", "ㄕㄨㄞˇ");
  checkEq(&container, &c, "gjiid", "ㄕㄨㄞˋ");
  checkEq(&container, &c, "gjo", "ㄕㄨㄟ");
  checkEq(&container, &c, "gjoe", "ㄕㄨㄟˊ");
  checkEq(&container, &c, "gjor", "ㄕㄨㄟˇ");
  checkEq(&container, &c, "gjod", "ㄕㄨㄟˋ");
  checkEq(&container, &c, "gjoo", "ㄕㄨㄢ");
  checkEq(&container, &c, "gjood", "ㄕㄨㄢˋ");
  checkEq(&container, &c, "gjpr", "ㄕㄨㄣˇ");
  checkEq(&container, &c, "gjpd", "ㄕㄨㄣˋ");
  checkEq(&container, &c, "gjll", "ㄕㄨㄤ");
  checkEq(&container, &c, "gjlle", "ㄕㄨㄤˊ");
  checkEq(&container, &c, "gjllr", "ㄕㄨㄤˇ");
  checkEq(&container, &c, "gjlld", "ㄕㄨㄤˋ");
  checkEq(&container, &c, "bd", "ㄖˋ");
  checkEq(&container, &c, "bkr", "ㄖㄜˇ");
  checkEq(&container, &c, "bkd", "ㄖㄜˋ");
  checkEq(&container, &c, "ble", "ㄖㄠˊ");
  checkEq(&container, &c, "blr", "ㄖㄠˇ");
  checkEq(&container, &c, "bld", "ㄖㄠˋ");
  checkEq(&container, &c, "bme", "ㄖㄡˊ");
  checkEq(&container, &c, "bmr", "ㄖㄡˇ");
  checkEq(&container, &c, "bmd", "ㄖㄡˋ");
  checkEq(&container, &c, "booe", "ㄖㄢˊ");
  checkEq(&container, &c, "boor", "ㄖㄢˇ");
  checkEq(&container, &c, "bood", "ㄖㄢˋ");
  checkEq(&container, &c, "bpe", "ㄖㄣˊ");
  checkEq(&container, &c, "bpr", "ㄖㄣˇ");
  checkEq(&container, &c, "bpd", "ㄖㄣˋ");
  checkEq(&container, &c, "bll", "ㄖㄤ");
  checkEq(&container, &c, "blle", "ㄖㄤˊ");
  checkEq(&container, &c, "bllr", "ㄖㄤˇ");
  checkEq(&container, &c, "blld", "ㄖㄤˋ");
  checkEq(&container, &c, "bn", "ㄖㄥ");
  checkEq(&container, &c, "bne", "ㄖㄥˊ");
  checkEq(&container, &c, "bnr", "ㄖㄥˇ");
  checkEq(&container, &c, "bnd", "ㄖㄥˋ");
  checkEq(&container, &c, "bje", "ㄖㄨˊ");
  checkEq(&container, &c, "bjr", "ㄖㄨˇ");
  checkEq(&container, &c, "bjd", "ㄖㄨˋ");
  checkEq(&container, &c, "bjie", "ㄖㄨㄛˊ");
  checkEq(&container, &c, "bjid", "ㄖㄨㄛˋ");
  checkEq(&container, &c, "bjoe", "ㄖㄨㄟˊ");
  checkEq(&container, &c, "bjor", "ㄖㄨㄟˇ");
  checkEq(&container, &c, "bjod", "ㄖㄨㄟˋ");
  checkEq(&container, &c, "bjooe", "ㄖㄨㄢˊ");
  checkEq(&container, &c, "bjoor", "ㄖㄨㄢˇ");
  checkEq(&container, &c, "bjood", "ㄖㄨㄢˋ");
  checkEq(&container, &c, "bjpe", "ㄖㄨㄣˊ");
  checkEq(&container, &c, "bjpr", "ㄖㄨㄣˇ");
  checkEq(&container, &c, "bjpd", "ㄖㄨㄣˋ");
  checkEq(&container, &c, "bjne", "ㄖㄨㄥˊ");
  checkEq(&container, &c, "bjnr", "ㄖㄨㄥˇ");
  checkEq(&container, &c, "bjnd", "ㄖㄨㄥˋ");
  checkEq(&container, &c, "y", "ㄗ");
  checkEq(&container, &c, "ye", "ㄗˊ");
  checkEq(&container, &c, "yr", "ㄗˇ");
  checkEq(&container, &c, "yd", "ㄗˋ");
  checkEq(&container, &c, "yy", "ㄗ˙");
  checkEq(&container, &c, "yuu", "ㄗㄚ");
  checkEq(&container, &c, "yuue", "ㄗㄚˊ");
  checkEq(&container, &c, "yuur", "ㄗㄚˇ");
  checkEq(&container, &c, "yke", "ㄗㄜˊ");
  checkEq(&container, &c, "ykr", "ㄗㄜˇ");
  checkEq(&container, &c, "ykd", "ㄗㄜˋ");
  checkEq(&container, &c, "yii", "ㄗㄞ");
  checkEq(&container, &c, "yiir", "ㄗㄞˇ");
  checkEq(&container, &c, "yiid", "ㄗㄞˋ");
  checkEq(&container, &c, "yoe", "ㄗㄟˊ");
  checkEq(&container, &c, "yl", "ㄗㄠ");
  checkEq(&container, &c, "yle", "ㄗㄠˊ");
  checkEq(&container, &c, "ylr", "ㄗㄠˇ");
  checkEq(&container, &c, "yld", "ㄗㄠˋ");
  checkEq(&container, &c, "ym", "ㄗㄡ");
  checkEq(&container, &c, "ymr", "ㄗㄡˇ");
  checkEq(&container, &c, "ymd", "ㄗㄡˋ");
  checkEq(&container, &c, "yoo", "ㄗㄢ");
  checkEq(&container, &c, "yooe", "ㄗㄢˊ");
  checkEq(&container, &c, "yoor", "ㄗㄢˇ");
  checkEq(&container, &c, "yood", "ㄗㄢˋ");
  checkEq(&container, &c, "yp", "ㄗㄣ");
  checkEq(&container, &c, "ypr", "ㄗㄣˇ");
  checkEq(&container, &c, "ypd", "ㄗㄣˋ");
  checkEq(&container, &c, "yll", "ㄗㄤ");
  checkEq(&container, &c, "yllr", "ㄗㄤˇ");
  checkEq(&container, &c, "ylld", "ㄗㄤˋ");
  checkEq(&container, &c, "yn", "ㄗㄥ");
  checkEq(&container, &c, "ynr", "ㄗㄥˇ");
  checkEq(&container, &c, "ynd", "ㄗㄥˋ");
  checkEq(&container, &c, "yj", "ㄗㄨ");
  checkEq(&container, &c, "yje", "ㄗㄨˊ");
  checkEq(&container, &c, "yjr", "ㄗㄨˇ");
  checkEq(&container, &c, "yjd", "ㄗㄨˋ");
  checkEq(&container, &c, "yji", "ㄗㄨㄛ");
  checkEq(&container, &c, "yjie", "ㄗㄨㄛˊ");
  checkEq(&container, &c, "yjir", "ㄗㄨㄛˇ");
  checkEq(&container, &c, "yjid", "ㄗㄨㄛˋ");
  checkEq(&container, &c, "yjiy", "ㄗㄨㄛ˙");
  checkEq(&container, &c, "yjo", "ㄗㄨㄟ");
  checkEq(&container, &c, "yjor", "ㄗㄨㄟˇ");
  checkEq(&container, &c, "yjod", "ㄗㄨㄟˋ");
  checkEq(&container, &c, "yjoo", "ㄗㄨㄢ");
  checkEq(&container, &c, "yjoor", "ㄗㄨㄢˇ");
  checkEq(&container, &c, "yjood", "ㄗㄨㄢˋ");
  checkEq(&container, &c, "yjp", "ㄗㄨㄣ");
  checkEq(&container, &c, "yjpr", "ㄗㄨㄣˇ");
  checkEq(&container, &c, "yjpd", "ㄗㄨㄣˋ");
  checkEq(&container, &c, "yjn", "ㄗㄨㄥ");
  checkEq(&container, &c, "yjnr", "ㄗㄨㄥˇ");
  checkEq(&container, &c, "yjnd", "ㄗㄨㄥˋ");
  checkEq(&container, &c, "h", "ㄘ");
  checkEq(&container, &c, "he", "ㄘˊ");
  checkEq(&container, &c, "hr", "ㄘˇ");
  checkEq(&container, &c, "hd", "ㄘˋ");
  checkEq(&container, &c, "huu", "ㄘㄚ");
  checkEq(&container, &c, "huur", "ㄘㄚˇ");
  checkEq(&container, &c, "huud", "ㄘㄚˋ");
  checkEq(&container, &c, "hkd", "ㄘㄜˋ");
  checkEq(&container, &c, "hii", "ㄘㄞ");
  checkEq(&container, &c, "hiie", "ㄘㄞˊ");
  checkEq(&container, &c, "hiir", "ㄘㄞˇ");
  checkEq(&container, &c, "hiid", "ㄘㄞˋ");
  checkEq(&container, &c, "hl", "ㄘㄠ");
  checkEq(&container, &c, "hle", "ㄘㄠˊ");
  checkEq(&container, &c, "hlr", "ㄘㄠˇ");
  checkEq(&container, &c, "hld", "ㄘㄠˋ");
  checkEq(&container, &c, "hm", "ㄘㄡ");
  checkEq(&container, &c, "hme", "ㄘㄡˊ");
  checkEq(&container, &c, "hmr", "ㄘㄡˇ");
  checkEq(&container, &c, "hmd", "ㄘㄡˋ");
  checkEq(&container, &c, "hoo", "ㄘㄢ");
  checkEq(&container, &c, "hooe", "ㄘㄢˊ");
  checkEq(&container, &c, "hoor", "ㄘㄢˇ");
  checkEq(&container, &c, "hood", "ㄘㄢˋ");
  checkEq(&container, &c, "hp", "ㄘㄣ");
  checkEq(&container, &c, "hpe", "ㄘㄣˊ");
  checkEq(&container, &c, "hll", "ㄘㄤ");
  checkEq(&container, &c, "hlle", "ㄘㄤˊ");
  checkEq(&container, &c, "hllr", "ㄘㄤˇ");
  checkEq(&container, &c, "hlld", "ㄘㄤˋ");
  checkEq(&container, &c, "hn", "ㄘㄥ");
  checkEq(&container, &c, "hne", "ㄘㄥˊ");
  checkEq(&container, &c, "hnr", "ㄘㄥˇ");
  checkEq(&container, &c, "hnd", "ㄘㄥˋ");
  checkEq(&container, &c, "hj", "ㄘㄨ");
  checkEq(&container, &c, "hje", "ㄘㄨˊ");
  checkEq(&container, &c, "hjr", "ㄘㄨˇ");
  checkEq(&container, &c, "hjd", "ㄘㄨˋ");
  checkEq(&container, &c, "hji", "ㄘㄨㄛ");
  checkEq(&container, &c, "hjie", "ㄘㄨㄛˊ");
  checkEq(&container, &c, "hjir", "ㄘㄨㄛˇ");
  checkEq(&container, &c, "hjid", "ㄘㄨㄛˋ");
  checkEq(&container, &c, "hjo", "ㄘㄨㄟ");
  checkEq(&container, &c, "hjor", "ㄘㄨㄟˇ");
  checkEq(&container, &c, "hjod", "ㄘㄨㄟˋ");
  checkEq(&container, &c, "hjoo", "ㄘㄨㄢ");
  checkEq(&container, &c, "hjooe", "ㄘㄨㄢˊ");
  checkEq(&container, &c, "hjoor", "ㄘㄨㄢˇ");
  checkEq(&container, &c, "hjood", "ㄘㄨㄢˋ");
  checkEq(&container, &c, "hjp", "ㄘㄨㄣ");
  checkEq(&container, &c, "hjpe", "ㄘㄨㄣˊ");
  checkEq(&container, &c, "hjpr", "ㄘㄨㄣˇ");
  checkEq(&container, &c, "hjpd", "ㄘㄨㄣˋ");
  checkEq(&container, &c, "hjn", "ㄘㄨㄥ");
  checkEq(&container, &c, "hjne", "ㄘㄨㄥˊ");
  checkEq(&container, &c, "hjnr", "ㄘㄨㄥˇ");
  checkEq(&container, &c, "hjnd", "ㄘㄨㄥˋ");
  checkEq(&container, &c, "n", "ㄙ");
  checkEq(&container, &c, "nr", "ㄙˇ");
  checkEq(&container, &c, "nd", "ㄙˋ");
  checkEq(&container, &c, "nuu", "ㄙㄚ");
  checkEq(&container, &c, "nuur", "ㄙㄚˇ");
  checkEq(&container, &c, "nuud", "ㄙㄚˋ");
  checkEq(&container, &c, "nuuy", "ㄙㄚ˙");
  checkEq(&container, &c, "nk", "ㄙㄜ");
  checkEq(&container, &c, "nkd", "ㄙㄜˋ");
  checkEq(&container, &c, "nii", "ㄙㄞ");
  checkEq(&container, &c, "niie", "ㄙㄞˊ");
  checkEq(&container, &c, "niir", "ㄙㄞˇ");
  checkEq(&container, &c, "niid", "ㄙㄞˋ");
  checkEq(&container, &c, "no", "ㄙㄟ");
  checkEq(&container, &c, "nl", "ㄙㄠ");
  checkEq(&container, &c, "nlr", "ㄙㄠˇ");
  checkEq(&container, &c, "nld", "ㄙㄠˋ");
  checkEq(&container, &c, "nm", "ㄙㄡ");
  checkEq(&container, &c, "nmr", "ㄙㄡˇ");
  checkEq(&container, &c, "nmd", "ㄙㄡˋ");
  checkEq(&container, &c, "noo", "ㄙㄢ");
  checkEq(&container, &c, "noor", "ㄙㄢˇ");
  checkEq(&container, &c, "nood", "ㄙㄢˋ");
  checkEq(&container, &c, "np", "ㄙㄣ");
  checkEq(&container, &c, "npr", "ㄙㄣˇ");
  checkEq(&container, &c, "nll", "ㄙㄤ");
  checkEq(&container, &c, "nllr", "ㄙㄤˇ");
  checkEq(&container, &c, "nlld", "ㄙㄤˋ");
  checkEq(&container, &c, "nnn", "ㄙㄥ");
  checkEq(&container, &c, "nnnd", "ㄙㄥˋ");
  checkEq(&container, &c, "nj", "ㄙㄨ");
  checkEq(&container, &c, "nje", "ㄙㄨˊ");
  checkEq(&container, &c, "njr", "ㄙㄨˇ");
  checkEq(&container, &c, "njd", "ㄙㄨˋ");
  checkEq(&container, &c, "nji", "ㄙㄨㄛ");
  checkEq(&container, &c, "njie", "ㄙㄨㄛˊ");
  checkEq(&container, &c, "njir", "ㄙㄨㄛˇ");
  checkEq(&container, &c, "njid", "ㄙㄨㄛˋ");
  checkEq(&container, &c, "njo", "ㄙㄨㄟ");
  checkEq(&container, &c, "njoe", "ㄙㄨㄟˊ");
  checkEq(&container, &c, "njor", "ㄙㄨㄟˇ");
  checkEq(&container, &c, "njod", "ㄙㄨㄟˋ");
  checkEq(&container, &c, "njoo", "ㄙㄨㄢ");
  checkEq(&container, &c, "njoor", "ㄙㄨㄢˇ");
  checkEq(&container, &c, "njood", "ㄙㄨㄢˋ");
  checkEq(&container, &c, "njp", "ㄙㄨㄣ");
  checkEq(&container, &c, "njpr", "ㄙㄨㄣˇ");
  checkEq(&container, &c, "njpd", "ㄙㄨㄣˋ");
  checkEq(&container, &c, "njn", "ㄙㄨㄥ");
  checkEq(&container, &c, "njne", "ㄙㄨㄥˊ");
  checkEq(&container, &c, "njnr", "ㄙㄨㄥˇ");
  checkEq(&container, &c, "njnd", "ㄙㄨㄥˋ");
  checkEq(&container, &c, "uu", "ㄚ");
  checkEq(&container, &c, "uue", "ㄚˊ");
  checkEq(&container, &c, "uud", "ㄚˋ");
  checkEq(&container, &c, "uuy", "ㄚ˙");
  checkEq(&container, &c, "i ", "ㄛ ");
  checkEq(&container, &c, "ie", "ㄛˊ");
  checkEq(&container, &c, "ir", "ㄛˇ");
  checkEq(&container, &c, "id", "ㄛˋ");
  checkEq(&container, &c, "k ", "ㄜ ");
  checkEq(&container, &c, "ke", "ㄜˊ");
  checkEq(&container, &c, "kr", "ㄜˇ");
  checkEq(&container, &c, "kd", "ㄜˋ");
  // checkEq(&container, &c, "be", "ㄝˊ");
  // checkEq(&container, &c, "br", "ㄝˇ");
  // checkEq(&container, &c, "bd", "ㄝˋ");
  // checkEq(&container, &c, "by", "ㄝ˙");
  checkEq(&container, &c, "ii", "ㄞ");
  checkEq(&container, &c, "iie", "ㄞˊ");
  checkEq(&container, &c, "iir", "ㄞˇ");
  checkEq(&container, &c, "iid", "ㄞˋ");
  checkEq(&container, &c, "od", "ㄟˋ");
  checkEq(&container, &c, "l", "ㄠ");
  checkEq(&container, &c, "le", "ㄠˊ");
  checkEq(&container, &c, "lr", "ㄠˇ");
  checkEq(&container, &c, "ld", "ㄠˋ");
  checkEq(&container, &c, "m", "ㄡ");
  checkEq(&container, &c, "me", "ㄡˊ");
  checkEq(&container, &c, "mr", "ㄡˇ");
  checkEq(&container, &c, "md", "ㄡˋ");
  checkEq(&container, &c, "my", "ㄡ˙");
  checkEq(&container, &c, "oo ", "ㄢ ");
  checkEq(&container, &c, "ooe", "ㄢˊ");
  checkEq(&container, &c, "oor", "ㄢˇ");
  checkEq(&container, &c, "ood", "ㄢˋ");
  checkEq(&container, &c, "p ", "ㄣ ");
  checkEq(&container, &c, "pe", "ㄣˊ");
  checkEq(&container, &c, "pr", "ㄣˇ");
  checkEq(&container, &c, "pd", "ㄣˋ");
  checkEq(&container, &c, "py", "ㄣ˙");
  checkEq(&container, &c, "ll ", "ㄤ ");
  checkEq(&container, &c, "lle", "ㄤˊ");
  checkEq(&container, &c, "llr", "ㄤˇ");
  checkEq(&container, &c, "lld", "ㄤˋ");
  checkEq(&container, &c, "nn ", "ㄥ ");
  checkEq(&container, &c, "nnd", "ㄥˋ");
  checkEq(&container, &c, "pp ", "ㄦ ");
  checkEq(&container, &c, "ppe", "ㄦˊ");
  checkEq(&container, &c, "ppr", "ㄦˇ");
  checkEq(&container, &c, "ppd", "ㄦˋ");
  checkEq(&container, &c, "ppy", "ㄦ˙");
  checkEq(&container, &c, "u", "ㄧ");
  checkEq(&container, &c, "ue", "ㄧˊ");
  checkEq(&container, &c, "ur", "ㄧˇ");
  checkEq(&container, &c, "ud", "ㄧˋ");
  checkEq(&container, &c, "uuu", "ㄧㄚ");
  checkEq(&container, &c, "uuue", "ㄧㄚˊ");
  checkEq(&container, &c, "uuur", "ㄧㄚˇ");
  checkEq(&container, &c, "uuud", "ㄧㄚˋ");
  checkEq(&container, &c, "uuuy", "ㄧㄚ˙");
  checkEq(&container, &c, "ui", "ㄧㄛ");
  checkEq(&container, &c, "uiy", "ㄧㄛ˙");
  checkEq(&container, &c, "ub", "ㄧㄝ");
  checkEq(&container, &c, "ube", "ㄧㄝˊ");
  checkEq(&container, &c, "ubr", "ㄧㄝˇ");
  checkEq(&container, &c, "ubd", "ㄧㄝˋ");
  checkEq(&container, &c, "uby", "ㄧㄝ˙");
  checkEq(&container, &c, "uiie", "ㄧㄞˊ");
  checkEq(&container, &c, "ul", "ㄧㄠ");
  checkEq(&container, &c, "ule", "ㄧㄠˊ");
  checkEq(&container, &c, "ulr", "ㄧㄠˇ");
  checkEq(&container, &c, "uld", "ㄧㄠˋ");
  checkEq(&container, &c, "um", "ㄧㄡ");
  checkEq(&container, &c, "ume", "ㄧㄡˊ");
  checkEq(&container, &c, "umr", "ㄧㄡˇ");
  checkEq(&container, &c, "umd", "ㄧㄡˋ");
  checkEq(&container, &c, "uoo", "ㄧㄢ");
  checkEq(&container, &c, "uooe", "ㄧㄢˊ");
  checkEq(&container, &c, "uoor", "ㄧㄢˇ");
  checkEq(&container, &c, "uood", "ㄧㄢˋ");
  checkEq(&container, &c, "up", "ㄧㄣ");
  checkEq(&container, &c, "upe", "ㄧㄣˊ");
  checkEq(&container, &c, "upr", "ㄧㄣˇ");
  checkEq(&container, &c, "upd", "ㄧㄣˋ");
  checkEq(&container, &c, "ull", "ㄧㄤ");
  checkEq(&container, &c, "ulle", "ㄧㄤˊ");
  checkEq(&container, &c, "ullr", "ㄧㄤˇ");
  checkEq(&container, &c, "ulld", "ㄧㄤˋ");
  checkEq(&container, &c, "un", "ㄧㄥ");
  checkEq(&container, &c, "une", "ㄧㄥˊ");
  checkEq(&container, &c, "unr", "ㄧㄥˇ");
  checkEq(&container, &c, "und", "ㄧㄥˋ");
  checkEq(&container, &c, "j", "ㄨ");
  checkEq(&container, &c, "je", "ㄨˊ");
  checkEq(&container, &c, "jr", "ㄨˇ");
  checkEq(&container, &c, "jd", "ㄨˋ");
  checkEq(&container, &c, "ju", "ㄨㄚ");
  checkEq(&container, &c, "jue", "ㄨㄚˊ");
  checkEq(&container, &c, "jur", "ㄨㄚˇ");
  checkEq(&container, &c, "jud", "ㄨㄚˋ");
  checkEq(&container, &c, "juy", "ㄨㄚ˙");
  checkEq(&container, &c, "ji", "ㄨㄛ");
  checkEq(&container, &c, "jir", "ㄨㄛˇ");
  checkEq(&container, &c, "jid", "ㄨㄛˋ");
  checkEq(&container, &c, "jii", "ㄨㄞ");
  checkEq(&container, &c, "jiir", "ㄨㄞˇ");
  checkEq(&container, &c, "jiid", "ㄨㄞˋ");
  checkEq(&container, &c, "jo", "ㄨㄟ");
  checkEq(&container, &c, "joe", "ㄨㄟˊ");
  checkEq(&container, &c, "jor", "ㄨㄟˇ");
  checkEq(&container, &c, "jod", "ㄨㄟˋ");
  checkEq(&container, &c, "joo", "ㄨㄢ");
  checkEq(&container, &c, "jooe", "ㄨㄢˊ");
  checkEq(&container, &c, "joor", "ㄨㄢˇ");
  checkEq(&container, &c, "jood", "ㄨㄢˋ");
  checkEq(&container, &c, "jp", "ㄨㄣ");
  checkEq(&container, &c, "jpe", "ㄨㄣˊ");
  checkEq(&container, &c, "jpr", "ㄨㄣˇ");
  checkEq(&container, &c, "jpd", "ㄨㄣˋ");
  checkEq(&container, &c, "jll", "ㄨㄤ");
  checkEq(&container, &c, "jlle", "ㄨㄤˊ");
  checkEq(&container, &c, "jllr", "ㄨㄤˇ");
  checkEq(&container, &c, "jlld", "ㄨㄤˋ");
  checkEq(&container, &c, "jn", "ㄨㄥ");
  checkEq(&container, &c, "jnr", "ㄨㄥˇ");
  checkEq(&container, &c, "jnd", "ㄨㄥˋ");
  checkEq(&container, &c, "mm", "ㄩ");
  checkEq(&container, &c, "mme", "ㄩˊ");
  checkEq(&container, &c, "mmr", "ㄩˇ");
  checkEq(&container, &c, "mmd", "ㄩˋ");
  checkEq(&container, &c, "mmb", "ㄩㄝ");
  checkEq(&container, &c, "mmbr", "ㄩㄝˇ");
  checkEq(&container, &c, "mmbd", "ㄩㄝˋ");
  checkEq(&container, &c, "mmoo", "ㄩㄢ");
  checkEq(&container, &c, "mmooe", "ㄩㄢˊ");
  checkEq(&container, &c, "mmoor", "ㄩㄢˇ");
  checkEq(&container, &c, "mmood", "ㄩㄢˋ");
  checkEq(&container, &c, "mmp", "ㄩㄣ");
  checkEq(&container, &c, "mmpe", "ㄩㄣˊ");
  checkEq(&container, &c, "mmpr", "ㄩㄣˇ");
  checkEq(&container, &c, "mmpd", "ㄩㄣˋ");
  checkEq(&container, &c, "mmn", "ㄩㄥ");
  checkEq(&container, &c, "mmne", "ㄩㄥˊ");
  checkEq(&container, &c, "mmnr", "ㄩㄥˇ");
  checkEq(&container, &c, "mmnd", "ㄩㄥˋ");
  ASSERT_TRUE(container.empty());
}

TEST(TekkonTests_Advanced, ETen26Keys) {
  // Testing handleETen26()
  Composer c = Composer("", ofETen26);
  std::vector<std::string> container = {};
  checkEq(&container, &c, "ket", "ㄎㄧㄤ");
  // checkEq(&container, &c, "vezf"), expected:
  // "ㄍㄧㄠˊ"); checkEq(&container, &c, "ven"),
  // "ㄍㄧㄣ");
  checkEq(&container, &c, "betf", "ㄅㄧㄤˊ");
  checkEq(&container, &c, "betk", "ㄅㄧㄤˋ");
  checkEq(&container, &c, "dxt", "ㄉㄨㄤ");
  checkEq(&container, &c, "ba", "ㄅㄚ");
  checkEq(&container, &c, "baf", "ㄅㄚˊ");
  checkEq(&container, &c, "baj", "ㄅㄚˇ");
  checkEq(&container, &c, "bak", "ㄅㄚˋ");
  checkEq(&container, &c, "bad", "ㄅㄚ˙");
  checkEq(&container, &c, "bo", "ㄅㄛ");
  checkEq(&container, &c, "bof", "ㄅㄛˊ");
  checkEq(&container, &c, "boj", "ㄅㄛˇ");
  checkEq(&container, &c, "bok", "ㄅㄛˋ");
  checkEq(&container, &c, "bod", "ㄅㄛ˙");
  checkEq(&container, &c, "bi", "ㄅㄞ");
  checkEq(&container, &c, "bif", "ㄅㄞˊ");
  checkEq(&container, &c, "bij", "ㄅㄞˇ");
  checkEq(&container, &c, "bik", "ㄅㄞˋ");
  checkEq(&container, &c, "bid", "ㄅㄞ˙");
  checkEq(&container, &c, "bq", "ㄅㄟ");
  checkEq(&container, &c, "bqj", "ㄅㄟˇ");
  checkEq(&container, &c, "bqk", "ㄅㄟˋ");
  checkEq(&container, &c, "bqd", "ㄅㄟ˙");
  checkEq(&container, &c, "bz", "ㄅㄠ");
  checkEq(&container, &c, "bzf", "ㄅㄠˊ");
  checkEq(&container, &c, "bzj", "ㄅㄠˇ");
  checkEq(&container, &c, "bzk", "ㄅㄠˋ");
  checkEq(&container, &c, "bm", "ㄅㄢ");
  checkEq(&container, &c, "bmj", "ㄅㄢˇ");
  checkEq(&container, &c, "bmk", "ㄅㄢˋ");
  checkEq(&container, &c, "bn", "ㄅㄣ");
  checkEq(&container, &c, "bnj", "ㄅㄣˇ");
  checkEq(&container, &c, "bnk", "ㄅㄣˋ");
  checkEq(&container, &c, "bt", "ㄅㄤ");
  checkEq(&container, &c, "btj", "ㄅㄤˇ");
  checkEq(&container, &c, "btk", "ㄅㄤˋ");
  checkEq(&container, &c, "bl", "ㄅㄥ");
  checkEq(&container, &c, "blf", "ㄅㄥˊ");
  checkEq(&container, &c, "blj", "ㄅㄥˇ");
  checkEq(&container, &c, "blk", "ㄅㄥˋ");
  checkEq(&container, &c, "be", "ㄅㄧ");
  checkEq(&container, &c, "bef", "ㄅㄧˊ");
  checkEq(&container, &c, "bej", "ㄅㄧˇ");
  checkEq(&container, &c, "bek", "ㄅㄧˋ");
  checkEq(&container, &c, "bew", "ㄅㄧㄝ");
  checkEq(&container, &c, "bewf", "ㄅㄧㄝˊ");
  checkEq(&container, &c, "bewj", "ㄅㄧㄝˇ");
  checkEq(&container, &c, "bewk", "ㄅㄧㄝˋ");
  checkEq(&container, &c, "bez", "ㄅㄧㄠ");
  checkEq(&container, &c, "bezj", "ㄅㄧㄠˇ");
  checkEq(&container, &c, "bezk", "ㄅㄧㄠˋ");
  checkEq(&container, &c, "bem", "ㄅㄧㄢ");
  checkEq(&container, &c, "bemf", "ㄅㄧㄢˊ");
  checkEq(&container, &c, "bemj", "ㄅㄧㄢˇ");
  checkEq(&container, &c, "bemk", "ㄅㄧㄢˋ");
  checkEq(&container, &c, "ben", "ㄅㄧㄣ");
  checkEq(&container, &c, "benj", "ㄅㄧㄣˇ");
  checkEq(&container, &c, "benk", "ㄅㄧㄣˋ");
  checkEq(&container, &c, "bel", "ㄅㄧㄥ");
  checkEq(&container, &c, "belj", "ㄅㄧㄥˇ");
  checkEq(&container, &c, "belk", "ㄅㄧㄥˋ");
  checkEq(&container, &c, "bx", "ㄅㄨ");
  checkEq(&container, &c, "bxf", "ㄅㄨˊ");
  checkEq(&container, &c, "bxj", "ㄅㄨˇ");
  checkEq(&container, &c, "bxk", "ㄅㄨˋ");
  checkEq(&container, &c, "pa", "ㄆㄚ");
  checkEq(&container, &c, "paf", "ㄆㄚˊ");
  checkEq(&container, &c, "paj", "ㄆㄚˇ");
  checkEq(&container, &c, "pak", "ㄆㄚˋ");
  checkEq(&container, &c, "pad", "ㄆㄚ˙");
  checkEq(&container, &c, "po", "ㄆㄛ");
  checkEq(&container, &c, "pof", "ㄆㄛˊ");
  checkEq(&container, &c, "poj", "ㄆㄛˇ");
  checkEq(&container, &c, "pok", "ㄆㄛˋ");
  checkEq(&container, &c, "pi", "ㄆㄞ");
  checkEq(&container, &c, "pif", "ㄆㄞˊ");
  checkEq(&container, &c, "pij", "ㄆㄞˇ");
  checkEq(&container, &c, "pik", "ㄆㄞˋ");
  checkEq(&container, &c, "pq", "ㄆㄟ");
  checkEq(&container, &c, "pqf", "ㄆㄟˊ");
  checkEq(&container, &c, "pqj", "ㄆㄟˇ");
  checkEq(&container, &c, "pqk", "ㄆㄟˋ");
  checkEq(&container, &c, "pz", "ㄆㄠ");
  checkEq(&container, &c, "pzf", "ㄆㄠˊ");
  checkEq(&container, &c, "pzj", "ㄆㄠˇ");
  checkEq(&container, &c, "pzk", "ㄆㄠˋ");
  checkEq(&container, &c, "pp", "ㄆㄡ");
  checkEq(&container, &c, "ppf", "ㄆㄡˊ");
  checkEq(&container, &c, "ppj", "ㄆㄡˇ");
  checkEq(&container, &c, "ppk", "ㄆㄡˋ");
  checkEq(&container, &c, "pm", "ㄆㄢ");
  checkEq(&container, &c, "pmf", "ㄆㄢˊ");
  checkEq(&container, &c, "pmj", "ㄆㄢˇ");
  checkEq(&container, &c, "pmk", "ㄆㄢˋ");
  checkEq(&container, &c, "pn", "ㄆㄣ");
  checkEq(&container, &c, "pnf", "ㄆㄣˊ");
  checkEq(&container, &c, "pnj", "ㄆㄣˇ");
  checkEq(&container, &c, "pnk", "ㄆㄣˋ");
  checkEq(&container, &c, "pt", "ㄆㄤ");
  checkEq(&container, &c, "ptf", "ㄆㄤˊ");
  checkEq(&container, &c, "ptj", "ㄆㄤˇ");
  checkEq(&container, &c, "ptk", "ㄆㄤˋ");
  checkEq(&container, &c, "pl", "ㄆㄥ");
  checkEq(&container, &c, "plf", "ㄆㄥˊ");
  checkEq(&container, &c, "plj", "ㄆㄥˇ");
  checkEq(&container, &c, "plk", "ㄆㄥˋ");
  checkEq(&container, &c, "pe", "ㄆㄧ");
  checkEq(&container, &c, "pef", "ㄆㄧˊ");
  checkEq(&container, &c, "pej", "ㄆㄧˇ");
  checkEq(&container, &c, "pek", "ㄆㄧˋ");
  checkEq(&container, &c, "pea", "ㄆㄧㄚ");
  checkEq(&container, &c, "pew", "ㄆㄧㄝ");
  checkEq(&container, &c, "pewj", "ㄆㄧㄝˇ");
  checkEq(&container, &c, "pewk", "ㄆㄧㄝˋ");
  checkEq(&container, &c, "pez", "ㄆㄧㄠ");
  checkEq(&container, &c, "pezf", "ㄆㄧㄠˊ");
  checkEq(&container, &c, "pezj", "ㄆㄧㄠˇ");
  checkEq(&container, &c, "pezk", "ㄆㄧㄠˋ");
  checkEq(&container, &c, "pem", "ㄆㄧㄢ");
  checkEq(&container, &c, "pemf", "ㄆㄧㄢˊ");
  checkEq(&container, &c, "pemj", "ㄆㄧㄢˇ");
  checkEq(&container, &c, "pemk", "ㄆㄧㄢˋ");
  checkEq(&container, &c, "pen", "ㄆㄧㄣ");
  checkEq(&container, &c, "penf", "ㄆㄧㄣˊ");
  checkEq(&container, &c, "penj", "ㄆㄧㄣˇ");
  checkEq(&container, &c, "penk", "ㄆㄧㄣˋ");
  checkEq(&container, &c, "pel", "ㄆㄧㄥ");
  checkEq(&container, &c, "pelf", "ㄆㄧㄥˊ");
  checkEq(&container, &c, "pelj", "ㄆㄧㄥˇ");
  checkEq(&container, &c, "pelk", "ㄆㄧㄥˋ");
  checkEq(&container, &c, "px", "ㄆㄨ");
  checkEq(&container, &c, "pxf", "ㄆㄨˊ");
  checkEq(&container, &c, "pxj", "ㄆㄨˇ");
  checkEq(&container, &c, "pxk", "ㄆㄨˋ");
  checkEq(&container, &c, "ma", "ㄇㄚ");
  checkEq(&container, &c, "maf", "ㄇㄚˊ");
  checkEq(&container, &c, "maj", "ㄇㄚˇ");
  checkEq(&container, &c, "mak", "ㄇㄚˋ");
  checkEq(&container, &c, "mad", "ㄇㄚ˙");
  checkEq(&container, &c, "mo", "ㄇㄛ");
  checkEq(&container, &c, "mof", "ㄇㄛˊ");
  checkEq(&container, &c, "moj", "ㄇㄛˇ");
  checkEq(&container, &c, "mok", "ㄇㄛˋ");
  checkEq(&container, &c, "mod", "ㄇㄛ˙");
  checkEq(&container, &c, "mr", "ㄇㄜ");
  checkEq(&container, &c, "mrk", "ㄇㄜˋ");
  checkEq(&container, &c, "mrd", "ㄇㄜ˙");
  checkEq(&container, &c, "mi", "ㄇㄞ");
  checkEq(&container, &c, "mif", "ㄇㄞˊ");
  checkEq(&container, &c, "mij", "ㄇㄞˇ");
  checkEq(&container, &c, "mik", "ㄇㄞˋ");
  checkEq(&container, &c, "mqf", "ㄇㄟˊ");
  checkEq(&container, &c, "mqj", "ㄇㄟˇ");
  checkEq(&container, &c, "mqk", "ㄇㄟˋ");
  checkEq(&container, &c, "mz", "ㄇㄠ");
  checkEq(&container, &c, "mzf", "ㄇㄠˊ");
  checkEq(&container, &c, "mzj", "ㄇㄠˇ");
  checkEq(&container, &c, "mzk", "ㄇㄠˋ");
  checkEq(&container, &c, "mpf", "ㄇㄡˊ");
  checkEq(&container, &c, "mpj", "ㄇㄡˇ");
  checkEq(&container, &c, "mpk", "ㄇㄡˋ");
  checkEq(&container, &c, "mm", "ㄇㄢ");
  checkEq(&container, &c, "mmf", "ㄇㄢˊ");
  checkEq(&container, &c, "mmj", "ㄇㄢˇ");
  checkEq(&container, &c, "mmk", "ㄇㄢˋ");
  checkEq(&container, &c, "mn", "ㄇㄣ");
  checkEq(&container, &c, "mnf", "ㄇㄣˊ");
  checkEq(&container, &c, "mnj", "ㄇㄣˇ");
  checkEq(&container, &c, "mnk", "ㄇㄣˋ");
  checkEq(&container, &c, "mnd", "ㄇㄣ˙");
  checkEq(&container, &c, "mt", "ㄇㄤ");
  checkEq(&container, &c, "mtf", "ㄇㄤˊ");
  checkEq(&container, &c, "mtj", "ㄇㄤˇ");
  checkEq(&container, &c, "mtk", "ㄇㄤˋ");
  checkEq(&container, &c, "ml", "ㄇㄥ");
  checkEq(&container, &c, "mlf", "ㄇㄥˊ");
  checkEq(&container, &c, "mlj", "ㄇㄥˇ");
  checkEq(&container, &c, "mlk", "ㄇㄥˋ");
  checkEq(&container, &c, "me", "ㄇㄧ");
  checkEq(&container, &c, "mef", "ㄇㄧˊ");
  checkEq(&container, &c, "mej", "ㄇㄧˇ");
  checkEq(&container, &c, "mek", "ㄇㄧˋ");
  checkEq(&container, &c, "mew", "ㄇㄧㄝ");
  checkEq(&container, &c, "mewf", "ㄇㄧㄝˊ");
  checkEq(&container, &c, "mewk", "ㄇㄧㄝˋ");
  checkEq(&container, &c, "mez", "ㄇㄧㄠ");
  checkEq(&container, &c, "mezf", "ㄇㄧㄠˊ");
  checkEq(&container, &c, "mezj", "ㄇㄧㄠˇ");
  checkEq(&container, &c, "mezk", "ㄇㄧㄠˋ");
  checkEq(&container, &c, "mepf", "ㄇㄧㄡˊ");
  checkEq(&container, &c, "mepj", "ㄇㄧㄡˇ");
  checkEq(&container, &c, "mepk", "ㄇㄧㄡˋ");
  checkEq(&container, &c, "mem", "ㄇㄧㄢ");
  checkEq(&container, &c, "memf", "ㄇㄧㄢˊ");
  checkEq(&container, &c, "memj", "ㄇㄧㄢˇ");
  checkEq(&container, &c, "memk", "ㄇㄧㄢˋ");
  checkEq(&container, &c, "men", "ㄇㄧㄣ");
  checkEq(&container, &c, "menf", "ㄇㄧㄣˊ");
  checkEq(&container, &c, "menj", "ㄇㄧㄣˇ");
  checkEq(&container, &c, "melf", "ㄇㄧㄥˊ");
  checkEq(&container, &c, "melj", "ㄇㄧㄥˇ");
  checkEq(&container, &c, "melk", "ㄇㄧㄥˋ");
  checkEq(&container, &c, "mxf", "ㄇㄨˊ");
  checkEq(&container, &c, "mxj", "ㄇㄨˇ");
  checkEq(&container, &c, "mxk", "ㄇㄨˋ");
  checkEq(&container, &c, "fa", "ㄈㄚ");
  checkEq(&container, &c, "faf", "ㄈㄚˊ");
  checkEq(&container, &c, "faj", "ㄈㄚˇ");
  checkEq(&container, &c, "fak", "ㄈㄚˋ");
  checkEq(&container, &c, "fof", "ㄈㄛˊ");
  checkEq(&container, &c, "fq", "ㄈㄟ");
  checkEq(&container, &c, "fqf", "ㄈㄟˊ");
  checkEq(&container, &c, "fqj", "ㄈㄟˇ");
  checkEq(&container, &c, "fqk", "ㄈㄟˋ");
  checkEq(&container, &c, "fp", "ㄈㄡ");
  checkEq(&container, &c, "fpf", "ㄈㄡˊ");
  checkEq(&container, &c, "fpj", "ㄈㄡˇ");
  checkEq(&container, &c, "fpk", "ㄈㄡˋ");
  checkEq(&container, &c, "fm", "ㄈㄢ");
  checkEq(&container, &c, "fmf", "ㄈㄢˊ");
  checkEq(&container, &c, "fmj", "ㄈㄢˇ");
  checkEq(&container, &c, "fmk", "ㄈㄢˋ");
  checkEq(&container, &c, "fn", "ㄈㄣ");
  checkEq(&container, &c, "fnf", "ㄈㄣˊ");
  checkEq(&container, &c, "fnj", "ㄈㄣˇ");
  checkEq(&container, &c, "fnk", "ㄈㄣˋ");
  checkEq(&container, &c, "fnd", "ㄈㄣ˙");
  checkEq(&container, &c, "ft", "ㄈㄤ");
  checkEq(&container, &c, "ftf", "ㄈㄤˊ");
  checkEq(&container, &c, "ftj", "ㄈㄤˇ");
  checkEq(&container, &c, "ftk", "ㄈㄤˋ");
  checkEq(&container, &c, "fl", "ㄈㄥ");
  checkEq(&container, &c, "flf", "ㄈㄥˊ");
  checkEq(&container, &c, "flj", "ㄈㄥˇ");
  checkEq(&container, &c, "flk", "ㄈㄥˋ");
  checkEq(&container, &c, "fezk", "ㄈㄧㄠˋ");
  checkEq(&container, &c, "fx", "ㄈㄨ");
  checkEq(&container, &c, "fxf", "ㄈㄨˊ");
  checkEq(&container, &c, "fxj", "ㄈㄨˇ");
  checkEq(&container, &c, "fxk", "ㄈㄨˋ");
  checkEq(&container, &c, "da", "ㄉㄚ");
  checkEq(&container, &c, "daf", "ㄉㄚˊ");
  checkEq(&container, &c, "daj", "ㄉㄚˇ");
  checkEq(&container, &c, "dak", "ㄉㄚˋ");
  checkEq(&container, &c, "dad", "ㄉㄚ˙");
  checkEq(&container, &c, "dr", "ㄉㄜ");
  checkEq(&container, &c, "drf", "ㄉㄜˊ");
  checkEq(&container, &c, "drd", "ㄉㄜ˙");
  checkEq(&container, &c, "di", "ㄉㄞ");
  checkEq(&container, &c, "dij", "ㄉㄞˇ");
  checkEq(&container, &c, "dik", "ㄉㄞˋ");
  checkEq(&container, &c, "dqj", "ㄉㄟˇ");
  checkEq(&container, &c, "dz", "ㄉㄠ");
  checkEq(&container, &c, "dzf", "ㄉㄠˊ");
  checkEq(&container, &c, "dzj", "ㄉㄠˇ");
  checkEq(&container, &c, "dzk", "ㄉㄠˋ");
  checkEq(&container, &c, "dp", "ㄉㄡ");
  checkEq(&container, &c, "dpf", "ㄉㄡˊ");
  checkEq(&container, &c, "dpj", "ㄉㄡˇ");
  checkEq(&container, &c, "dpk", "ㄉㄡˋ");
  checkEq(&container, &c, "dm", "ㄉㄢ");
  checkEq(&container, &c, "dmj", "ㄉㄢˇ");
  checkEq(&container, &c, "dmk", "ㄉㄢˋ");
  checkEq(&container, &c, "dnk", "ㄉㄣˋ");
  checkEq(&container, &c, "dt", "ㄉㄤ");
  checkEq(&container, &c, "dtj", "ㄉㄤˇ");
  checkEq(&container, &c, "dtk", "ㄉㄤˋ");
  checkEq(&container, &c, "dl", "ㄉㄥ");
  checkEq(&container, &c, "dlj", "ㄉㄥˇ");
  checkEq(&container, &c, "dlk", "ㄉㄥˋ");
  checkEq(&container, &c, "de", "ㄉㄧ");
  checkEq(&container, &c, "def", "ㄉㄧˊ");
  checkEq(&container, &c, "dej", "ㄉㄧˇ");
  checkEq(&container, &c, "dek", "ㄉㄧˋ");
  checkEq(&container, &c, "deaj", "ㄉㄧㄚˇ");
  checkEq(&container, &c, "dew", "ㄉㄧㄝ");
  checkEq(&container, &c, "dewf", "ㄉㄧㄝˊ");
  checkEq(&container, &c, "dewj", "ㄉㄧㄝˇ");
  checkEq(&container, &c, "dewk", "ㄉㄧㄝˋ");
  checkEq(&container, &c, "dez", "ㄉㄧㄠ");
  checkEq(&container, &c, "dezj", "ㄉㄧㄠˇ");
  checkEq(&container, &c, "dezk", "ㄉㄧㄠˋ");
  checkEq(&container, &c, "dep", "ㄉㄧㄡ");
  checkEq(&container, &c, "dem", "ㄉㄧㄢ");
  checkEq(&container, &c, "demf", "ㄉㄧㄢˊ");
  checkEq(&container, &c, "demj", "ㄉㄧㄢˇ");
  checkEq(&container, &c, "demk", "ㄉㄧㄢˋ");
  checkEq(&container, &c, "del", "ㄉㄧㄥ");
  checkEq(&container, &c, "delf", "ㄉㄧㄥˊ");
  checkEq(&container, &c, "delj", "ㄉㄧㄥˇ");
  checkEq(&container, &c, "delk", "ㄉㄧㄥˋ");
  checkEq(&container, &c, "dx", "ㄉㄨ");
  checkEq(&container, &c, "dxf", "ㄉㄨˊ");
  checkEq(&container, &c, "dxj", "ㄉㄨˇ");
  checkEq(&container, &c, "dxk", "ㄉㄨˋ");
  checkEq(&container, &c, "dxo", "ㄉㄨㄛ");
  checkEq(&container, &c, "dxof", "ㄉㄨㄛˊ");
  checkEq(&container, &c, "dxoj", "ㄉㄨㄛˇ");
  checkEq(&container, &c, "dxok", "ㄉㄨㄛˋ");
  checkEq(&container, &c, "dxod", "ㄉㄨㄛ˙");
  checkEq(&container, &c, "dxq", "ㄉㄨㄟ");
  checkEq(&container, &c, "dxqj", "ㄉㄨㄟˇ");
  checkEq(&container, &c, "dxqk", "ㄉㄨㄟˋ");
  checkEq(&container, &c, "dxm", "ㄉㄨㄢ");
  checkEq(&container, &c, "dxmj", "ㄉㄨㄢˇ");
  checkEq(&container, &c, "dxmk", "ㄉㄨㄢˋ");
  checkEq(&container, &c, "dxn", "ㄉㄨㄣ");
  checkEq(&container, &c, "dxnj", "ㄉㄨㄣˇ");
  checkEq(&container, &c, "dxnk", "ㄉㄨㄣˋ");
  checkEq(&container, &c, "dxl", "ㄉㄨㄥ");
  checkEq(&container, &c, "dxlj", "ㄉㄨㄥˇ");
  checkEq(&container, &c, "dxlk", "ㄉㄨㄥˋ");
  checkEq(&container, &c, "ta", "ㄊㄚ");
  checkEq(&container, &c, "taj", "ㄊㄚˇ");
  checkEq(&container, &c, "tak", "ㄊㄚˋ");
  checkEq(&container, &c, "trk", "ㄊㄜˋ");
  checkEq(&container, &c, "ti", "ㄊㄞ");
  checkEq(&container, &c, "tif", "ㄊㄞˊ");
  checkEq(&container, &c, "tij", "ㄊㄞˇ");
  checkEq(&container, &c, "tik", "ㄊㄞˋ");
  checkEq(&container, &c, "tid", "ㄊㄞ˙");
  checkEq(&container, &c, "tz", "ㄊㄠ");
  checkEq(&container, &c, "tzf", "ㄊㄠˊ");
  checkEq(&container, &c, "tzj", "ㄊㄠˇ");
  checkEq(&container, &c, "tzk", "ㄊㄠˋ");
  checkEq(&container, &c, "tzd", "ㄊㄠ˙");
  checkEq(&container, &c, "tp", "ㄊㄡ");
  checkEq(&container, &c, "tpf", "ㄊㄡˊ");
  checkEq(&container, &c, "tpj", "ㄊㄡˇ");
  checkEq(&container, &c, "tpk", "ㄊㄡˋ");
  checkEq(&container, &c, "tpd", "ㄊㄡ˙");
  checkEq(&container, &c, "tm", "ㄊㄢ");
  checkEq(&container, &c, "tmf", "ㄊㄢˊ");
  checkEq(&container, &c, "tmj", "ㄊㄢˇ");
  checkEq(&container, &c, "tmk", "ㄊㄢˋ");
  checkEq(&container, &c, "tt", "ㄊㄤ");
  checkEq(&container, &c, "ttf", "ㄊㄤˊ");
  checkEq(&container, &c, "ttj", "ㄊㄤˇ");
  checkEq(&container, &c, "ttk", "ㄊㄤˋ");
  checkEq(&container, &c, "tl", "ㄊㄥ");
  checkEq(&container, &c, "tlf", "ㄊㄥˊ");
  checkEq(&container, &c, "tlk", "ㄊㄥˋ");
  checkEq(&container, &c, "te", "ㄊㄧ");
  checkEq(&container, &c, "tef", "ㄊㄧˊ");
  checkEq(&container, &c, "tej", "ㄊㄧˇ");
  checkEq(&container, &c, "tek", "ㄊㄧˋ");
  checkEq(&container, &c, "tew", "ㄊㄧㄝ");
  checkEq(&container, &c, "tewf", "ㄊㄧㄝˊ");
  checkEq(&container, &c, "tewj", "ㄊㄧㄝˇ");
  checkEq(&container, &c, "tewk", "ㄊㄧㄝˋ");
  checkEq(&container, &c, "tez", "ㄊㄧㄠ");
  checkEq(&container, &c, "tezf", "ㄊㄧㄠˊ");
  checkEq(&container, &c, "tezj", "ㄊㄧㄠˇ");
  checkEq(&container, &c, "tezk", "ㄊㄧㄠˋ");
  checkEq(&container, &c, "tem", "ㄊㄧㄢ");
  checkEq(&container, &c, "temf", "ㄊㄧㄢˊ");
  checkEq(&container, &c, "temj", "ㄊㄧㄢˇ");
  checkEq(&container, &c, "temk", "ㄊㄧㄢˋ");
  checkEq(&container, &c, "tel", "ㄊㄧㄥ");
  checkEq(&container, &c, "telf", "ㄊㄧㄥˊ");
  checkEq(&container, &c, "telj", "ㄊㄧㄥˇ");
  checkEq(&container, &c, "telk", "ㄊㄧㄥˋ");
  checkEq(&container, &c, "tx", "ㄊㄨ");
  checkEq(&container, &c, "txf", "ㄊㄨˊ");
  checkEq(&container, &c, "txj", "ㄊㄨˇ");
  checkEq(&container, &c, "txk", "ㄊㄨˋ");
  checkEq(&container, &c, "txo", "ㄊㄨㄛ");
  checkEq(&container, &c, "txof", "ㄊㄨㄛˊ");
  checkEq(&container, &c, "txoj", "ㄊㄨㄛˇ");
  checkEq(&container, &c, "txok", "ㄊㄨㄛˋ");
  checkEq(&container, &c, "txq", "ㄊㄨㄟ");
  checkEq(&container, &c, "txqf", "ㄊㄨㄟˊ");
  checkEq(&container, &c, "txqj", "ㄊㄨㄟˇ");
  checkEq(&container, &c, "txqk", "ㄊㄨㄟˋ");
  checkEq(&container, &c, "txm", "ㄊㄨㄢ");
  checkEq(&container, &c, "txmf", "ㄊㄨㄢˊ");
  checkEq(&container, &c, "txmj", "ㄊㄨㄢˇ");
  checkEq(&container, &c, "txmk", "ㄊㄨㄢˋ");
  checkEq(&container, &c, "txn", "ㄊㄨㄣ");
  checkEq(&container, &c, "txnf", "ㄊㄨㄣˊ");
  checkEq(&container, &c, "txnj", "ㄊㄨㄣˇ");
  checkEq(&container, &c, "txnk", "ㄊㄨㄣˋ");
  checkEq(&container, &c, "txl", "ㄊㄨㄥ");
  checkEq(&container, &c, "txlf", "ㄊㄨㄥˊ");
  checkEq(&container, &c, "txlj", "ㄊㄨㄥˇ");
  checkEq(&container, &c, "txlk", "ㄊㄨㄥˋ");
  checkEq(&container, &c, "na", "ㄋㄚ");
  checkEq(&container, &c, "naf", "ㄋㄚˊ");
  checkEq(&container, &c, "naj", "ㄋㄚˇ");
  checkEq(&container, &c, "nak", "ㄋㄚˋ");
  checkEq(&container, &c, "nad", "ㄋㄚ˙");
  checkEq(&container, &c, "nrk", "ㄋㄜˋ");
  checkEq(&container, &c, "nrd", "ㄋㄜ˙");
  checkEq(&container, &c, "nif", "ㄋㄞˊ");
  checkEq(&container, &c, "nij", "ㄋㄞˇ");
  checkEq(&container, &c, "nik", "ㄋㄞˋ");
  checkEq(&container, &c, "nqf", "ㄋㄟˊ");
  checkEq(&container, &c, "nqj", "ㄋㄟˇ");
  checkEq(&container, &c, "nqk", "ㄋㄟˋ");
  checkEq(&container, &c, "nz", "ㄋㄠ");
  checkEq(&container, &c, "nzf", "ㄋㄠˊ");
  checkEq(&container, &c, "nzj", "ㄋㄠˇ");
  checkEq(&container, &c, "nzk", "ㄋㄠˋ");
  checkEq(&container, &c, "npf", "ㄋㄡˊ");
  checkEq(&container, &c, "npj", "ㄋㄡˇ");
  checkEq(&container, &c, "npk", "ㄋㄡˋ");
  checkEq(&container, &c, "nm", "ㄋㄢ");
  checkEq(&container, &c, "nmf", "ㄋㄢˊ");
  checkEq(&container, &c, "nmj", "ㄋㄢˇ");
  checkEq(&container, &c, "nmk", "ㄋㄢˋ");
  checkEq(&container, &c, "nnj", "ㄋㄣˇ");
  checkEq(&container, &c, "nnk", "ㄋㄣˋ");
  checkEq(&container, &c, "nt", "ㄋㄤ");
  checkEq(&container, &c, "ntf", "ㄋㄤˊ");
  checkEq(&container, &c, "ntj", "ㄋㄤˇ");
  checkEq(&container, &c, "ntk", "ㄋㄤˋ");
  checkEq(&container, &c, "ntd", "ㄋㄤ˙");
  checkEq(&container, &c, "nlf", "ㄋㄥˊ");
  checkEq(&container, &c, "nlj", "ㄋㄥˇ");
  checkEq(&container, &c, "ne", "ㄋㄧ");
  checkEq(&container, &c, "nef", "ㄋㄧˊ");
  checkEq(&container, &c, "nej", "ㄋㄧˇ");
  checkEq(&container, &c, "nek", "ㄋㄧˋ");
  checkEq(&container, &c, "new", "ㄋㄧㄝ");
  checkEq(&container, &c, "newf", "ㄋㄧㄝˊ");
  checkEq(&container, &c, "newk", "ㄋㄧㄝˋ");
  checkEq(&container, &c, "nezj", "ㄋㄧㄠˇ");
  checkEq(&container, &c, "nezk", "ㄋㄧㄠˋ");
  checkEq(&container, &c, "nep", "ㄋㄧㄡ");
  checkEq(&container, &c, "nepf", "ㄋㄧㄡˊ");
  checkEq(&container, &c, "nepj", "ㄋㄧㄡˇ");
  checkEq(&container, &c, "nepk", "ㄋㄧㄡˋ");
  checkEq(&container, &c, "nem", "ㄋㄧㄢ");
  checkEq(&container, &c, "nemf", "ㄋㄧㄢˊ");
  checkEq(&container, &c, "nemj", "ㄋㄧㄢˇ");
  checkEq(&container, &c, "nemk", "ㄋㄧㄢˋ");
  checkEq(&container, &c, "nen", "ㄋㄧㄣ");
  checkEq(&container, &c, "nenf", "ㄋㄧㄣˊ");
  checkEq(&container, &c, "nenj", "ㄋㄧㄣˇ");
  checkEq(&container, &c, "nenk", "ㄋㄧㄣˋ");
  checkEq(&container, &c, "netf", "ㄋㄧㄤˊ");
  checkEq(&container, &c, "netj", "ㄋㄧㄤˇ");
  checkEq(&container, &c, "netk", "ㄋㄧㄤˋ");
  checkEq(&container, &c, "nelf", "ㄋㄧㄥˊ");
  checkEq(&container, &c, "nelj", "ㄋㄧㄥˇ");
  checkEq(&container, &c, "nelk", "ㄋㄧㄥˋ");
  checkEq(&container, &c, "nxf", "ㄋㄨˊ");
  checkEq(&container, &c, "nxj", "ㄋㄨˇ");
  checkEq(&container, &c, "nxk", "ㄋㄨˋ");
  checkEq(&container, &c, "nxof", "ㄋㄨㄛˊ");
  checkEq(&container, &c, "nxoj", "ㄋㄨㄛˇ");
  checkEq(&container, &c, "nxok", "ㄋㄨㄛˋ");
  checkEq(&container, &c, "nxqf", "ㄋㄨㄟˊ");
  checkEq(&container, &c, "nxmf", "ㄋㄨㄢˊ");
  checkEq(&container, &c, "nxmj", "ㄋㄨㄢˇ");
  checkEq(&container, &c, "nxmk", "ㄋㄨㄢˋ");
  checkEq(&container, &c, "nxnf", "ㄋㄨㄣˊ");
  checkEq(&container, &c, "nxlf", "ㄋㄨㄥˊ");
  checkEq(&container, &c, "nxlj", "ㄋㄨㄥˇ");
  checkEq(&container, &c, "nxlk", "ㄋㄨㄥˋ");
  checkEq(&container, &c, "nuf", "ㄋㄩˊ");
  checkEq(&container, &c, "nuj", "ㄋㄩˇ");
  checkEq(&container, &c, "nuk", "ㄋㄩˋ");
  checkEq(&container, &c, "nuwk", "ㄋㄩㄝˋ");
  checkEq(&container, &c, "la", "ㄌㄚ");
  checkEq(&container, &c, "laf", "ㄌㄚˊ");
  checkEq(&container, &c, "laj", "ㄌㄚˇ");
  checkEq(&container, &c, "lak", "ㄌㄚˋ");
  checkEq(&container, &c, "lad", "ㄌㄚ˙");
  checkEq(&container, &c, "lo", "ㄌㄛ");
  checkEq(&container, &c, "lod", "ㄌㄛ˙");
  checkEq(&container, &c, "lr", "ㄌㄜ");
  checkEq(&container, &c, "lrf", "ㄌㄜˊ");
  checkEq(&container, &c, "lrk", "ㄌㄜˋ");
  checkEq(&container, &c, "lrd", "ㄌㄜ˙");
  checkEq(&container, &c, "lif", "ㄌㄞˊ");
  checkEq(&container, &c, "lij", "ㄌㄞˇ");
  checkEq(&container, &c, "lik", "ㄌㄞˋ");
  checkEq(&container, &c, "lq", "ㄌㄟ");
  checkEq(&container, &c, "lqf", "ㄌㄟˊ");
  checkEq(&container, &c, "lqj", "ㄌㄟˇ");
  checkEq(&container, &c, "lqk", "ㄌㄟˋ");
  checkEq(&container, &c, "lqd", "ㄌㄟ˙");
  checkEq(&container, &c, "lz", "ㄌㄠ");
  checkEq(&container, &c, "lzf", "ㄌㄠˊ");
  checkEq(&container, &c, "lzj", "ㄌㄠˇ");
  checkEq(&container, &c, "lzk", "ㄌㄠˋ");
  checkEq(&container, &c, "lp", "ㄌㄡ");
  checkEq(&container, &c, "lpf", "ㄌㄡˊ");
  checkEq(&container, &c, "lpj", "ㄌㄡˇ");
  checkEq(&container, &c, "lpk", "ㄌㄡˋ");
  checkEq(&container, &c, "lpd", "ㄌㄡ˙");
  checkEq(&container, &c, "lmf", "ㄌㄢˊ");
  checkEq(&container, &c, "lmj", "ㄌㄢˇ");
  checkEq(&container, &c, "lmk", "ㄌㄢˋ");
  checkEq(&container, &c, "lt", "ㄌㄤ");
  checkEq(&container, &c, "ltf", "ㄌㄤˊ");
  checkEq(&container, &c, "ltj", "ㄌㄤˇ");
  checkEq(&container, &c, "ltk", "ㄌㄤˋ");
  checkEq(&container, &c, "ll", "ㄌㄥ");
  checkEq(&container, &c, "llf", "ㄌㄥˊ");
  checkEq(&container, &c, "llj", "ㄌㄥˇ");
  checkEq(&container, &c, "llk", "ㄌㄥˋ");
  checkEq(&container, &c, "le", "ㄌㄧ");
  checkEq(&container, &c, "lef", "ㄌㄧˊ");
  checkEq(&container, &c, "lej", "ㄌㄧˇ");
  checkEq(&container, &c, "lek", "ㄌㄧˋ");
  checkEq(&container, &c, "led", "ㄌㄧ˙");
  checkEq(&container, &c, "leaj", "ㄌㄧㄚˇ");
  checkEq(&container, &c, "lew", "ㄌㄧㄝ");
  checkEq(&container, &c, "lewf", "ㄌㄧㄝˊ");
  checkEq(&container, &c, "lewj", "ㄌㄧㄝˇ");
  checkEq(&container, &c, "lewk", "ㄌㄧㄝˋ");
  checkEq(&container, &c, "lez", "ㄌㄧㄠ");
  checkEq(&container, &c, "lezf", "ㄌㄧㄠˊ");
  checkEq(&container, &c, "lezj", "ㄌㄧㄠˇ");
  checkEq(&container, &c, "lezk", "ㄌㄧㄠˋ");
  checkEq(&container, &c, "lep", "ㄌㄧㄡ");
  checkEq(&container, &c, "lepf", "ㄌㄧㄡˊ");
  checkEq(&container, &c, "lepj", "ㄌㄧㄡˇ");
  checkEq(&container, &c, "lepk", "ㄌㄧㄡˋ");
  checkEq(&container, &c, "lem", "ㄌㄧㄢ");
  checkEq(&container, &c, "lemf", "ㄌㄧㄢˊ");
  checkEq(&container, &c, "lemj", "ㄌㄧㄢˇ");
  checkEq(&container, &c, "lemk", "ㄌㄧㄢˋ");
  checkEq(&container, &c, "lenf", "ㄌㄧㄣˊ");
  checkEq(&container, &c, "lenj", "ㄌㄧㄣˇ");
  checkEq(&container, &c, "lenk", "ㄌㄧㄣˋ");
  checkEq(&container, &c, "letf", "ㄌㄧㄤˊ");
  checkEq(&container, &c, "letj", "ㄌㄧㄤˇ");
  checkEq(&container, &c, "letk", "ㄌㄧㄤˋ");
  checkEq(&container, &c, "lel", "ㄌㄧㄥ");
  checkEq(&container, &c, "lelf", "ㄌㄧㄥˊ");
  checkEq(&container, &c, "lelj", "ㄌㄧㄥˇ");
  checkEq(&container, &c, "lelk", "ㄌㄧㄥˋ");
  checkEq(&container, &c, "lx", "ㄌㄨ");
  checkEq(&container, &c, "lxf", "ㄌㄨˊ");
  checkEq(&container, &c, "lxj", "ㄌㄨˇ");
  checkEq(&container, &c, "lxk", "ㄌㄨˋ");
  checkEq(&container, &c, "lxo", "ㄌㄨㄛ");
  checkEq(&container, &c, "lxof", "ㄌㄨㄛˊ");
  checkEq(&container, &c, "lxoj", "ㄌㄨㄛˇ");
  checkEq(&container, &c, "lxok", "ㄌㄨㄛˋ");
  checkEq(&container, &c, "lxod", "ㄌㄨㄛ˙");
  checkEq(&container, &c, "lxmf", "ㄌㄨㄢˊ");
  checkEq(&container, &c, "lxmj", "ㄌㄨㄢˇ");
  checkEq(&container, &c, "lxmk", "ㄌㄨㄢˋ");
  checkEq(&container, &c, "lxn", "ㄌㄨㄣ");
  checkEq(&container, &c, "lxnf", "ㄌㄨㄣˊ");
  checkEq(&container, &c, "lxnj", "ㄌㄨㄣˇ");
  checkEq(&container, &c, "lxnk", "ㄌㄨㄣˋ");
  checkEq(&container, &c, "lxl", "ㄌㄨㄥ");
  checkEq(&container, &c, "lxlf", "ㄌㄨㄥˊ");
  checkEq(&container, &c, "lxlj", "ㄌㄨㄥˇ");
  checkEq(&container, &c, "lxlk", "ㄌㄨㄥˋ");
  checkEq(&container, &c, "lu", "ㄌㄩ");
  checkEq(&container, &c, "luf", "ㄌㄩˊ");
  checkEq(&container, &c, "luj", "ㄌㄩˇ");
  checkEq(&container, &c, "luk", "ㄌㄩˋ");
  checkEq(&container, &c, "luw", "ㄌㄩㄝ");
  checkEq(&container, &c, "luwj", "ㄌㄩㄝˇ");
  checkEq(&container, &c, "luwk", "ㄌㄩㄝˋ");
  checkEq(&container, &c, "lumf", "ㄌㄩㄢˊ");
  checkEq(&container, &c, "lumj", "ㄌㄩㄢˇ");
  checkEq(&container, &c, "va", "ㄍㄚ");
  checkEq(&container, &c, "vaf", "ㄍㄚˊ");
  checkEq(&container, &c, "vaj", "ㄍㄚˇ");
  checkEq(&container, &c, "vak", "ㄍㄚˋ");
  checkEq(&container, &c, "vad", "ㄍㄚ˙");
  checkEq(&container, &c, "vr", "ㄍㄜ");
  checkEq(&container, &c, "vrf", "ㄍㄜˊ");
  checkEq(&container, &c, "vrj", "ㄍㄜˇ");
  checkEq(&container, &c, "vrk", "ㄍㄜˋ");
  checkEq(&container, &c, "vrd", "ㄍㄜ˙");
  checkEq(&container, &c, "vi", "ㄍㄞ");
  checkEq(&container, &c, "vij", "ㄍㄞˇ");
  checkEq(&container, &c, "vik", "ㄍㄞˋ");
  checkEq(&container, &c, "vqj", "ㄍㄟˇ");
  checkEq(&container, &c, "vz", "ㄍㄠ");
  checkEq(&container, &c, "vzj", "ㄍㄠˇ");
  checkEq(&container, &c, "vzk", "ㄍㄠˋ");
  checkEq(&container, &c, "vp", "ㄍㄡ");
  checkEq(&container, &c, "vpj", "ㄍㄡˇ");
  checkEq(&container, &c, "vpk", "ㄍㄡˋ");
  checkEq(&container, &c, "vm", "ㄍㄢ");
  checkEq(&container, &c, "vmj", "ㄍㄢˇ");
  checkEq(&container, &c, "vmk", "ㄍㄢˋ");
  checkEq(&container, &c, "vn", "ㄍㄣ");
  checkEq(&container, &c, "vnf", "ㄍㄣˊ");
  checkEq(&container, &c, "vnj", "ㄍㄣˇ");
  checkEq(&container, &c, "vnk", "ㄍㄣˋ");
  checkEq(&container, &c, "vt", "ㄍㄤ");
  checkEq(&container, &c, "vtj", "ㄍㄤˇ");
  checkEq(&container, &c, "vtk", "ㄍㄤˋ");
  checkEq(&container, &c, "vl", "ㄍㄥ");
  checkEq(&container, &c, "vlj", "ㄍㄥˇ");
  checkEq(&container, &c, "vlk", "ㄍㄥˋ");
  checkEq(&container, &c, "vx", "ㄍㄨ");
  checkEq(&container, &c, "vxf", "ㄍㄨˊ");
  checkEq(&container, &c, "vxj", "ㄍㄨˇ");
  checkEq(&container, &c, "vxk", "ㄍㄨˋ");
  checkEq(&container, &c, "vxa", "ㄍㄨㄚ");
  checkEq(&container, &c, "vxaf", "ㄍㄨㄚˊ");
  checkEq(&container, &c, "vxaj", "ㄍㄨㄚˇ");
  checkEq(&container, &c, "vxak", "ㄍㄨㄚˋ");
  checkEq(&container, &c, "vxo", "ㄍㄨㄛ");
  checkEq(&container, &c, "vxof", "ㄍㄨㄛˊ");
  checkEq(&container, &c, "vxoj", "ㄍㄨㄛˇ");
  checkEq(&container, &c, "vxok", "ㄍㄨㄛˋ");
  checkEq(&container, &c, "vxi", "ㄍㄨㄞ");
  checkEq(&container, &c, "vxij", "ㄍㄨㄞˇ");
  checkEq(&container, &c, "vxik", "ㄍㄨㄞˋ");
  checkEq(&container, &c, "vxq", "ㄍㄨㄟ");
  checkEq(&container, &c, "vxqj", "ㄍㄨㄟˇ");
  checkEq(&container, &c, "vxqk", "ㄍㄨㄟˋ");
  checkEq(&container, &c, "vxm", "ㄍㄨㄢ");
  checkEq(&container, &c, "vxmj", "ㄍㄨㄢˇ");
  checkEq(&container, &c, "vxmk", "ㄍㄨㄢˋ");
  checkEq(&container, &c, "vxn", "ㄍㄨㄣ");
  checkEq(&container, &c, "vxnj", "ㄍㄨㄣˇ");
  checkEq(&container, &c, "vxnk", "ㄍㄨㄣˋ");
  checkEq(&container, &c, "vxt", "ㄍㄨㄤ");
  checkEq(&container, &c, "vxtj", "ㄍㄨㄤˇ");
  checkEq(&container, &c, "vxtk", "ㄍㄨㄤˋ");
  checkEq(&container, &c, "vxl", "ㄍㄨㄥ");
  checkEq(&container, &c, "vxlf", "ㄍㄨㄥˊ");
  checkEq(&container, &c, "vxlj", "ㄍㄨㄥˇ");
  checkEq(&container, &c, "vxlk", "ㄍㄨㄥˋ");
  checkEq(&container, &c, "ka", "ㄎㄚ");
  checkEq(&container, &c, "kaj", "ㄎㄚˇ");
  checkEq(&container, &c, "kak", "ㄎㄚˋ");
  checkEq(&container, &c, "kr", "ㄎㄜ");
  checkEq(&container, &c, "krf", "ㄎㄜˊ");
  checkEq(&container, &c, "krj", "ㄎㄜˇ");
  checkEq(&container, &c, "krk", "ㄎㄜˋ");
  checkEq(&container, &c, "ki", "ㄎㄞ");
  checkEq(&container, &c, "kij", "ㄎㄞˇ");
  checkEq(&container, &c, "kik", "ㄎㄞˋ");
  checkEq(&container, &c, "kz", "ㄎㄠ");
  checkEq(&container, &c, "kzj", "ㄎㄠˇ");
  checkEq(&container, &c, "kzk", "ㄎㄠˋ");
  checkEq(&container, &c, "kp", "ㄎㄡ");
  checkEq(&container, &c, "kpj", "ㄎㄡˇ");
  checkEq(&container, &c, "kpk", "ㄎㄡˋ");
  checkEq(&container, &c, "km", "ㄎㄢ");
  checkEq(&container, &c, "kmj", "ㄎㄢˇ");
  checkEq(&container, &c, "kmk", "ㄎㄢˋ");
  checkEq(&container, &c, "kn", "ㄎㄣ");
  checkEq(&container, &c, "knj", "ㄎㄣˇ");
  checkEq(&container, &c, "knk", "ㄎㄣˋ");
  checkEq(&container, &c, "kt", "ㄎㄤ");
  checkEq(&container, &c, "ktf", "ㄎㄤˊ");
  checkEq(&container, &c, "ktj", "ㄎㄤˇ");
  checkEq(&container, &c, "ktk", "ㄎㄤˋ");
  checkEq(&container, &c, "kl", "ㄎㄥ");
  checkEq(&container, &c, "klj", "ㄎㄥˇ");
  checkEq(&container, &c, "kx", "ㄎㄨ");
  checkEq(&container, &c, "kxf", "ㄎㄨˊ");
  checkEq(&container, &c, "kxj", "ㄎㄨˇ");
  checkEq(&container, &c, "kxk", "ㄎㄨˋ");
  checkEq(&container, &c, "kxa", "ㄎㄨㄚ");
  checkEq(&container, &c, "kxaj", "ㄎㄨㄚˇ");
  checkEq(&container, &c, "kxak", "ㄎㄨㄚˋ");
  checkEq(&container, &c, "kxok", "ㄎㄨㄛˋ");
  checkEq(&container, &c, "kxi", "ㄎㄨㄞ");
  checkEq(&container, &c, "kxij", "ㄎㄨㄞˇ");
  checkEq(&container, &c, "kxik", "ㄎㄨㄞˋ");
  checkEq(&container, &c, "kxq", "ㄎㄨㄟ");
  checkEq(&container, &c, "kxqf", "ㄎㄨㄟˊ");
  checkEq(&container, &c, "kxqj", "ㄎㄨㄟˇ");
  checkEq(&container, &c, "kxqk", "ㄎㄨㄟˋ");
  checkEq(&container, &c, "kxm", "ㄎㄨㄢ");
  checkEq(&container, &c, "kxmj", "ㄎㄨㄢˇ");
  checkEq(&container, &c, "kxmk", "ㄎㄨㄢˋ");
  checkEq(&container, &c, "kxn", "ㄎㄨㄣ");
  checkEq(&container, &c, "kxnj", "ㄎㄨㄣˇ");
  checkEq(&container, &c, "kxnk", "ㄎㄨㄣˋ");
  checkEq(&container, &c, "kxt", "ㄎㄨㄤ");
  checkEq(&container, &c, "kxtf", "ㄎㄨㄤˊ");
  checkEq(&container, &c, "kxtj", "ㄎㄨㄤˇ");
  checkEq(&container, &c, "kxtk", "ㄎㄨㄤˋ");
  checkEq(&container, &c, "kxl", "ㄎㄨㄥ");
  checkEq(&container, &c, "kxlj", "ㄎㄨㄥˇ");
  checkEq(&container, &c, "kxlk", "ㄎㄨㄥˋ");
  checkEq(&container, &c, "ha", "ㄏㄚ");
  checkEq(&container, &c, "haf", "ㄏㄚˊ");
  checkEq(&container, &c, "haj", "ㄏㄚˇ");
  checkEq(&container, &c, "hr", "ㄏㄜ");
  checkEq(&container, &c, "hrf", "ㄏㄜˊ");
  checkEq(&container, &c, "hrj", "ㄏㄜˇ");
  checkEq(&container, &c, "hrk", "ㄏㄜˋ");
  checkEq(&container, &c, "hi", "ㄏㄞ");
  checkEq(&container, &c, "hif", "ㄏㄞˊ");
  checkEq(&container, &c, "hij", "ㄏㄞˇ");
  checkEq(&container, &c, "hik", "ㄏㄞˋ");
  checkEq(&container, &c, "hq", "ㄏㄟ");
  checkEq(&container, &c, "hqj", "ㄏㄟˇ");
  checkEq(&container, &c, "hz", "ㄏㄠ");
  checkEq(&container, &c, "hzf", "ㄏㄠˊ");
  checkEq(&container, &c, "hzj", "ㄏㄠˇ");
  checkEq(&container, &c, "hzk", "ㄏㄠˋ");
  checkEq(&container, &c, "hp", "ㄏㄡ");
  checkEq(&container, &c, "hpf", "ㄏㄡˊ");
  checkEq(&container, &c, "hpj", "ㄏㄡˇ");
  checkEq(&container, &c, "hpk", "ㄏㄡˋ");
  checkEq(&container, &c, "hm", "ㄏㄢ");
  checkEq(&container, &c, "hmf", "ㄏㄢˊ");
  checkEq(&container, &c, "hmj", "ㄏㄢˇ");
  checkEq(&container, &c, "hmk", "ㄏㄢˋ");
  checkEq(&container, &c, "hn", "ㄏㄣ");
  checkEq(&container, &c, "hnf", "ㄏㄣˊ");
  checkEq(&container, &c, "hnj", "ㄏㄣˇ");
  checkEq(&container, &c, "hnk", "ㄏㄣˋ");
  checkEq(&container, &c, "ht", "ㄏㄤ");
  checkEq(&container, &c, "htf", "ㄏㄤˊ");
  checkEq(&container, &c, "htj", "ㄏㄤˇ");
  checkEq(&container, &c, "htk", "ㄏㄤˋ");
  checkEq(&container, &c, "hl", "ㄏㄥ");
  checkEq(&container, &c, "hlf", "ㄏㄥˊ");
  checkEq(&container, &c, "hlk", "ㄏㄥˋ");
  checkEq(&container, &c, "hx", "ㄏㄨ");
  checkEq(&container, &c, "hxf", "ㄏㄨˊ");
  checkEq(&container, &c, "hxj", "ㄏㄨˇ");
  checkEq(&container, &c, "hxk", "ㄏㄨˋ");
  checkEq(&container, &c, "hxa", "ㄏㄨㄚ");
  checkEq(&container, &c, "hxaf", "ㄏㄨㄚˊ");
  checkEq(&container, &c, "hxaj", "ㄏㄨㄚˇ");
  checkEq(&container, &c, "hxak", "ㄏㄨㄚˋ");
  checkEq(&container, &c, "hxo", "ㄏㄨㄛ");
  checkEq(&container, &c, "hxof", "ㄏㄨㄛˊ");
  checkEq(&container, &c, "hxoj", "ㄏㄨㄛˇ");
  checkEq(&container, &c, "hxok", "ㄏㄨㄛˋ");
  checkEq(&container, &c, "hxod", "ㄏㄨㄛ˙");
  checkEq(&container, &c, "hxif", "ㄏㄨㄞˊ");
  checkEq(&container, &c, "hxik", "ㄏㄨㄞˋ");
  checkEq(&container, &c, "hxq", "ㄏㄨㄟ");
  checkEq(&container, &c, "hxqf", "ㄏㄨㄟˊ");
  checkEq(&container, &c, "hxqj", "ㄏㄨㄟˇ");
  checkEq(&container, &c, "hxqk", "ㄏㄨㄟˋ");
  checkEq(&container, &c, "hxm", "ㄏㄨㄢ");
  checkEq(&container, &c, "hxmf", "ㄏㄨㄢˊ");
  checkEq(&container, &c, "hxmj", "ㄏㄨㄢˇ");
  checkEq(&container, &c, "hxmk", "ㄏㄨㄢˋ");
  checkEq(&container, &c, "hxn", "ㄏㄨㄣ");
  checkEq(&container, &c, "hxnf", "ㄏㄨㄣˊ");
  checkEq(&container, &c, "hxnj", "ㄏㄨㄣˇ");
  checkEq(&container, &c, "hxnk", "ㄏㄨㄣˋ");
  checkEq(&container, &c, "hxt", "ㄏㄨㄤ");
  checkEq(&container, &c, "hxtf", "ㄏㄨㄤˊ");
  checkEq(&container, &c, "hxtj", "ㄏㄨㄤˇ");
  checkEq(&container, &c, "hxtk", "ㄏㄨㄤˋ");
  checkEq(&container, &c, "hxtd", "ㄏㄨㄤ˙");
  checkEq(&container, &c, "hxl", "ㄏㄨㄥ");
  checkEq(&container, &c, "hxlf", "ㄏㄨㄥˊ");
  checkEq(&container, &c, "hxlj", "ㄏㄨㄥˇ");
  checkEq(&container, &c, "hxlk", "ㄏㄨㄥˋ");
  checkEq(&container, &c, "ge", "ㄐㄧ");
  checkEq(&container, &c, "gef", "ㄐㄧˊ");
  checkEq(&container, &c, "gej", "ㄐㄧˇ");
  checkEq(&container, &c, "gek", "ㄐㄧˋ");
  checkEq(&container, &c, "gea", "ㄐㄧㄚ");
  checkEq(&container, &c, "geaf", "ㄐㄧㄚˊ");
  checkEq(&container, &c, "geaj", "ㄐㄧㄚˇ");
  checkEq(&container, &c, "geak", "ㄐㄧㄚˋ");
  checkEq(&container, &c, "gew", "ㄐㄧㄝ");
  checkEq(&container, &c, "gewf", "ㄐㄧㄝˊ");
  checkEq(&container, &c, "gewj", "ㄐㄧㄝˇ");
  checkEq(&container, &c, "gewk", "ㄐㄧㄝˋ");
  checkEq(&container, &c, "gewd", "ㄐㄧㄝ˙");
  checkEq(&container, &c, "gez", "ㄐㄧㄠ");
  checkEq(&container, &c, "gezf", "ㄐㄧㄠˊ");
  checkEq(&container, &c, "gezj", "ㄐㄧㄠˇ");
  checkEq(&container, &c, "gezk", "ㄐㄧㄠˋ");
  checkEq(&container, &c, "gep", "ㄐㄧㄡ");
  checkEq(&container, &c, "gepj", "ㄐㄧㄡˇ");
  checkEq(&container, &c, "gepk", "ㄐㄧㄡˋ");
  checkEq(&container, &c, "gem", "ㄐㄧㄢ");
  checkEq(&container, &c, "gemj", "ㄐㄧㄢˇ");
  checkEq(&container, &c, "gemk", "ㄐㄧㄢˋ");
  checkEq(&container, &c, "gen", "ㄐㄧㄣ");
  checkEq(&container, &c, "genj", "ㄐㄧㄣˇ");
  checkEq(&container, &c, "genk", "ㄐㄧㄣˋ");
  checkEq(&container, &c, "get", "ㄐㄧㄤ");
  checkEq(&container, &c, "getf", "ㄐㄧㄤˊ");
  checkEq(&container, &c, "getj", "ㄐㄧㄤˇ");
  checkEq(&container, &c, "getk", "ㄐㄧㄤˋ");
  checkEq(&container, &c, "gel", "ㄐㄧㄥ");
  checkEq(&container, &c, "gelj", "ㄐㄧㄥˇ");
  checkEq(&container, &c, "gelk", "ㄐㄧㄥˋ");
  checkEq(&container, &c, "gu", "ㄐㄩ");
  checkEq(&container, &c, "guf", "ㄐㄩˊ");
  checkEq(&container, &c, "guj", "ㄐㄩˇ");
  checkEq(&container, &c, "guk", "ㄐㄩˋ");
  checkEq(&container, &c, "guw", "ㄐㄩㄝ");
  checkEq(&container, &c, "guwf", "ㄐㄩㄝˊ");
  checkEq(&container, &c, "guwj", "ㄐㄩㄝˇ");
  checkEq(&container, &c, "guwk", "ㄐㄩㄝˋ");
  checkEq(&container, &c, "gum", "ㄐㄩㄢ");
  checkEq(&container, &c, "gumj", "ㄐㄩㄢˇ");
  checkEq(&container, &c, "gumk", "ㄐㄩㄢˋ");
  checkEq(&container, &c, "gun", "ㄐㄩㄣ");
  checkEq(&container, &c, "gunf", "ㄐㄩㄣˊ");
  checkEq(&container, &c, "gunj", "ㄐㄩㄣˇ");
  checkEq(&container, &c, "gunk", "ㄐㄩㄣˋ");
  checkEq(&container, &c, "gul", "ㄐㄩㄥ");
  checkEq(&container, &c, "gulj", "ㄐㄩㄥˇ");
  checkEq(&container, &c, "gulk", "ㄐㄩㄥˋ");
  checkEq(&container, &c, "vd", "ㄑ˙");
  checkEq(&container, &c, "ve", "ㄑㄧ");
  checkEq(&container, &c, "vef", "ㄑㄧˊ");
  checkEq(&container, &c, "vej", "ㄑㄧˇ");
  checkEq(&container, &c, "vek", "ㄑㄧˋ");
  checkEq(&container, &c, "vea", "ㄑㄧㄚ");
  checkEq(&container, &c, "veaf", "ㄑㄧㄚˊ");
  checkEq(&container, &c, "veaj", "ㄑㄧㄚˇ");
  checkEq(&container, &c, "veak", "ㄑㄧㄚˋ");
  checkEq(&container, &c, "vew", "ㄑㄧㄝ");
  checkEq(&container, &c, "vewf", "ㄑㄧㄝˊ");
  checkEq(&container, &c, "vewj", "ㄑㄧㄝˇ");
  checkEq(&container, &c, "vewk", "ㄑㄧㄝˋ");
  checkEq(&container, &c, "vez", "ㄑㄧㄠ");
  checkEq(&container, &c, "vezf", "ㄑㄧㄠˊ");
  checkEq(&container, &c, "vezj", "ㄑㄧㄠˇ");
  checkEq(&container, &c, "vezk", "ㄑㄧㄠˋ");
  checkEq(&container, &c, "vep", "ㄑㄧㄡ");
  checkEq(&container, &c, "vepf", "ㄑㄧㄡˊ");
  checkEq(&container, &c, "vepj", "ㄑㄧㄡˇ");
  checkEq(&container, &c, "vepk", "ㄑㄧㄡˋ");
  checkEq(&container, &c, "vem", "ㄑㄧㄢ");
  checkEq(&container, &c, "vemf", "ㄑㄧㄢˊ");
  checkEq(&container, &c, "vemj", "ㄑㄧㄢˇ");
  checkEq(&container, &c, "vemk", "ㄑㄧㄢˋ");
  checkEq(&container, &c, "ven", "ㄑㄧㄣ");
  checkEq(&container, &c, "venf", "ㄑㄧㄣˊ");
  checkEq(&container, &c, "venj", "ㄑㄧㄣˇ");
  checkEq(&container, &c, "venk", "ㄑㄧㄣˋ");
  checkEq(&container, &c, "vet", "ㄑㄧㄤ");
  checkEq(&container, &c, "vetf", "ㄑㄧㄤˊ");
  checkEq(&container, &c, "vetj", "ㄑㄧㄤˇ");
  checkEq(&container, &c, "vetk", "ㄑㄧㄤˋ");
  checkEq(&container, &c, "vel", "ㄑㄧㄥ");
  checkEq(&container, &c, "velf", "ㄑㄧㄥˊ");
  checkEq(&container, &c, "velj", "ㄑㄧㄥˇ");
  checkEq(&container, &c, "velk", "ㄑㄧㄥˋ");
  checkEq(&container, &c, "vu", "ㄑㄩ");
  checkEq(&container, &c, "vuf", "ㄑㄩˊ");
  checkEq(&container, &c, "vuj", "ㄑㄩˇ");
  checkEq(&container, &c, "vuk", "ㄑㄩˋ");
  checkEq(&container, &c, "vuw", "ㄑㄩㄝ");
  checkEq(&container, &c, "vuwf", "ㄑㄩㄝˊ");
  checkEq(&container, &c, "vuwk", "ㄑㄩㄝˋ");
  checkEq(&container, &c, "vum", "ㄑㄩㄢ");
  checkEq(&container, &c, "vumf", "ㄑㄩㄢˊ");
  checkEq(&container, &c, "vumj", "ㄑㄩㄢˇ");
  checkEq(&container, &c, "vumk", "ㄑㄩㄢˋ");
  checkEq(&container, &c, "vun", "ㄑㄩㄣ");
  checkEq(&container, &c, "vunf", "ㄑㄩㄣˊ");
  checkEq(&container, &c, "vunj", "ㄑㄩㄣˇ");
  checkEq(&container, &c, "vunk", "ㄑㄩㄣˋ");
  checkEq(&container, &c, "vul", "ㄑㄩㄥ");
  checkEq(&container, &c, "vulf", "ㄑㄩㄥˊ");
  checkEq(&container, &c, "vulj", "ㄑㄩㄥˇ");
  checkEq(&container, &c, "vulk", "ㄑㄩㄥˋ");
  checkEq(&container, &c, "ce", "ㄒㄧ");
  checkEq(&container, &c, "cef", "ㄒㄧˊ");
  checkEq(&container, &c, "cej", "ㄒㄧˇ");
  checkEq(&container, &c, "cek", "ㄒㄧˋ");
  checkEq(&container, &c, "cea", "ㄒㄧㄚ");
  checkEq(&container, &c, "ceaf", "ㄒㄧㄚˊ");
  checkEq(&container, &c, "ceaj", "ㄒㄧㄚˇ");
  checkEq(&container, &c, "ceak", "ㄒㄧㄚˋ");
  checkEq(&container, &c, "cew", "ㄒㄧㄝ");
  checkEq(&container, &c, "cewf", "ㄒㄧㄝˊ");
  checkEq(&container, &c, "cewj", "ㄒㄧㄝˇ");
  checkEq(&container, &c, "cewk", "ㄒㄧㄝˋ");
  checkEq(&container, &c, "cez", "ㄒㄧㄠ");
  checkEq(&container, &c, "cezf", "ㄒㄧㄠˊ");
  checkEq(&container, &c, "cezj", "ㄒㄧㄠˇ");
  checkEq(&container, &c, "cezk", "ㄒㄧㄠˋ");
  checkEq(&container, &c, "cep", "ㄒㄧㄡ");
  checkEq(&container, &c, "cepf", "ㄒㄧㄡˊ");
  checkEq(&container, &c, "cepj", "ㄒㄧㄡˇ");
  checkEq(&container, &c, "cepk", "ㄒㄧㄡˋ");
  checkEq(&container, &c, "cem", "ㄒㄧㄢ");
  checkEq(&container, &c, "cemf", "ㄒㄧㄢˊ");
  checkEq(&container, &c, "cemj", "ㄒㄧㄢˇ");
  checkEq(&container, &c, "cemk", "ㄒㄧㄢˋ");
  checkEq(&container, &c, "cen", "ㄒㄧㄣ");
  checkEq(&container, &c, "cenf", "ㄒㄧㄣˊ");
  checkEq(&container, &c, "cenj", "ㄒㄧㄣˇ");
  checkEq(&container, &c, "cenk", "ㄒㄧㄣˋ");
  checkEq(&container, &c, "cet", "ㄒㄧㄤ");
  checkEq(&container, &c, "cetf", "ㄒㄧㄤˊ");
  checkEq(&container, &c, "cetj", "ㄒㄧㄤˇ");
  checkEq(&container, &c, "cetk", "ㄒㄧㄤˋ");
  checkEq(&container, &c, "cel", "ㄒㄧㄥ");
  checkEq(&container, &c, "celf", "ㄒㄧㄥˊ");
  checkEq(&container, &c, "celj", "ㄒㄧㄥˇ");
  checkEq(&container, &c, "celk", "ㄒㄧㄥˋ");
  checkEq(&container, &c, "cu", "ㄒㄩ");
  checkEq(&container, &c, "cuf", "ㄒㄩˊ");
  checkEq(&container, &c, "cuj", "ㄒㄩˇ");
  checkEq(&container, &c, "cuk", "ㄒㄩˋ");
  checkEq(&container, &c, "cuw", "ㄒㄩㄝ");
  checkEq(&container, &c, "cuwf", "ㄒㄩㄝˊ");
  checkEq(&container, &c, "cuwj", "ㄒㄩㄝˇ");
  checkEq(&container, &c, "cuwk", "ㄒㄩㄝˋ");
  checkEq(&container, &c, "cum", "ㄒㄩㄢ");
  checkEq(&container, &c, "cumf", "ㄒㄩㄢˊ");
  checkEq(&container, &c, "cumj", "ㄒㄩㄢˇ");
  checkEq(&container, &c, "cumk", "ㄒㄩㄢˋ");
  checkEq(&container, &c, "cun", "ㄒㄩㄣ");
  checkEq(&container, &c, "cunf", "ㄒㄩㄣˊ");
  checkEq(&container, &c, "cunk", "ㄒㄩㄣˋ");
  checkEq(&container, &c, "cul", "ㄒㄩㄥ");
  checkEq(&container, &c, "culf", "ㄒㄩㄥˊ");
  checkEq(&container, &c, "culj", "ㄒㄩㄥˇ");
  checkEq(&container, &c, "culk", "ㄒㄩㄥˋ");
  checkEq(&container, &c, "g", "ㄓ");
  checkEq(&container, &c, "gf", "ㄓˊ");
  checkEq(&container, &c, "gj", "ㄓˇ");
  checkEq(&container, &c, "gk", "ㄓˋ");
  checkEq(&container, &c, "ga", "ㄓㄚ");
  checkEq(&container, &c, "gaf", "ㄓㄚˊ");
  checkEq(&container, &c, "gaj", "ㄓㄚˇ");
  checkEq(&container, &c, "gak", "ㄓㄚˋ");
  checkEq(&container, &c, "gr", "ㄓㄜ");
  checkEq(&container, &c, "grf", "ㄓㄜˊ");
  checkEq(&container, &c, "grj", "ㄓㄜˇ");
  checkEq(&container, &c, "grk", "ㄓㄜˋ");
  checkEq(&container, &c, "grd", "ㄓㄜ˙");
  checkEq(&container, &c, "gi", "ㄓㄞ");
  checkEq(&container, &c, "gif", "ㄓㄞˊ");
  checkEq(&container, &c, "gij", "ㄓㄞˇ");
  checkEq(&container, &c, "gik", "ㄓㄞˋ");
  checkEq(&container, &c, "gqk", "ㄓㄟˋ");
  checkEq(&container, &c, "gz", "ㄓㄠ");
  checkEq(&container, &c, "gzf", "ㄓㄠˊ");
  checkEq(&container, &c, "gzj", "ㄓㄠˇ");
  checkEq(&container, &c, "gzk", "ㄓㄠˋ");
  checkEq(&container, &c, "gp", "ㄓㄡ");
  checkEq(&container, &c, "gpf", "ㄓㄡˊ");
  checkEq(&container, &c, "gpj", "ㄓㄡˇ");
  checkEq(&container, &c, "gpk", "ㄓㄡˋ");
  checkEq(&container, &c, "gm", "ㄓㄢ");
  checkEq(&container, &c, "gmj", "ㄓㄢˇ");
  checkEq(&container, &c, "gmk", "ㄓㄢˋ");
  checkEq(&container, &c, "gn", "ㄓㄣ");
  checkEq(&container, &c, "gnf", "ㄓㄣˊ");
  checkEq(&container, &c, "gnj", "ㄓㄣˇ");
  checkEq(&container, &c, "gnk", "ㄓㄣˋ");
  checkEq(&container, &c, "gt", "ㄓㄤ");
  checkEq(&container, &c, "gtj", "ㄓㄤˇ");
  checkEq(&container, &c, "gtk", "ㄓㄤˋ");
  checkEq(&container, &c, "gl", "ㄓㄥ");
  checkEq(&container, &c, "glj", "ㄓㄥˇ");
  checkEq(&container, &c, "glk", "ㄓㄥˋ");
  checkEq(&container, &c, "gx", "ㄓㄨ");
  checkEq(&container, &c, "gxf", "ㄓㄨˊ");
  checkEq(&container, &c, "gxj", "ㄓㄨˇ");
  checkEq(&container, &c, "gxk", "ㄓㄨˋ");
  checkEq(&container, &c, "gxa", "ㄓㄨㄚ");
  checkEq(&container, &c, "gxaj", "ㄓㄨㄚˇ");
  checkEq(&container, &c, "gxo", "ㄓㄨㄛ");
  checkEq(&container, &c, "gxof", "ㄓㄨㄛˊ");
  checkEq(&container, &c, "gxok", "ㄓㄨㄛˋ");
  checkEq(&container, &c, "gxi", "ㄓㄨㄞ");
  checkEq(&container, &c, "gxij", "ㄓㄨㄞˇ");
  checkEq(&container, &c, "gxik", "ㄓㄨㄞˋ");
  checkEq(&container, &c, "gxq", "ㄓㄨㄟ");
  checkEq(&container, &c, "gxqj", "ㄓㄨㄟˇ");
  checkEq(&container, &c, "gxqk", "ㄓㄨㄟˋ");
  checkEq(&container, &c, "gxm", "ㄓㄨㄢ");
  checkEq(&container, &c, "gxmj", "ㄓㄨㄢˇ");
  checkEq(&container, &c, "gxmk", "ㄓㄨㄢˋ");
  checkEq(&container, &c, "gxn", "ㄓㄨㄣ");
  checkEq(&container, &c, "gxnj", "ㄓㄨㄣˇ");
  checkEq(&container, &c, "gxnk", "ㄓㄨㄣˋ");
  checkEq(&container, &c, "gxt", "ㄓㄨㄤ");
  checkEq(&container, &c, "gxtj", "ㄓㄨㄤˇ");
  checkEq(&container, &c, "gxtk", "ㄓㄨㄤˋ");
  checkEq(&container, &c, "gxl", "ㄓㄨㄥ");
  checkEq(&container, &c, "gxlj", "ㄓㄨㄥˇ");
  checkEq(&container, &c, "gxlk", "ㄓㄨㄥˋ");
  checkEq(&container, &c, "y", "ㄔ");
  checkEq(&container, &c, "yf", "ㄔˊ");
  checkEq(&container, &c, "yj", "ㄔˇ");
  checkEq(&container, &c, "yk", "ㄔˋ");
  checkEq(&container, &c, "ya", "ㄔㄚ");
  checkEq(&container, &c, "yaf", "ㄔㄚˊ");
  checkEq(&container, &c, "yaj", "ㄔㄚˇ");
  checkEq(&container, &c, "yak", "ㄔㄚˋ");
  checkEq(&container, &c, "yr", "ㄔㄜ");
  checkEq(&container, &c, "yrj", "ㄔㄜˇ");
  checkEq(&container, &c, "yrk", "ㄔㄜˋ");
  checkEq(&container, &c, "yi", "ㄔㄞ");
  checkEq(&container, &c, "yif", "ㄔㄞˊ");
  checkEq(&container, &c, "yij", "ㄔㄞˇ");
  checkEq(&container, &c, "yik", "ㄔㄞˋ");
  checkEq(&container, &c, "yz", "ㄔㄠ");
  checkEq(&container, &c, "yzf", "ㄔㄠˊ");
  checkEq(&container, &c, "yzj", "ㄔㄠˇ");
  checkEq(&container, &c, "yzk", "ㄔㄠˋ");
  checkEq(&container, &c, "yp", "ㄔㄡ");
  checkEq(&container, &c, "ypf", "ㄔㄡˊ");
  checkEq(&container, &c, "ypj", "ㄔㄡˇ");
  checkEq(&container, &c, "ypk", "ㄔㄡˋ");
  checkEq(&container, &c, "ym", "ㄔㄢ");
  checkEq(&container, &c, "ymf", "ㄔㄢˊ");
  checkEq(&container, &c, "ymj", "ㄔㄢˇ");
  checkEq(&container, &c, "ymk", "ㄔㄢˋ");
  checkEq(&container, &c, "yn", "ㄔㄣ");
  checkEq(&container, &c, "ynf", "ㄔㄣˊ");
  checkEq(&container, &c, "ynj", "ㄔㄣˇ");
  checkEq(&container, &c, "ynk", "ㄔㄣˋ");
  checkEq(&container, &c, "ynd", "ㄔㄣ˙");
  checkEq(&container, &c, "yt", "ㄔㄤ");
  checkEq(&container, &c, "ytf", "ㄔㄤˊ");
  checkEq(&container, &c, "ytj", "ㄔㄤˇ");
  checkEq(&container, &c, "ytk", "ㄔㄤˋ");
  checkEq(&container, &c, "yl", "ㄔㄥ");
  checkEq(&container, &c, "ylf", "ㄔㄥˊ");
  checkEq(&container, &c, "ylj", "ㄔㄥˇ");
  checkEq(&container, &c, "ylk", "ㄔㄥˋ");
  checkEq(&container, &c, "yx", "ㄔㄨ");
  checkEq(&container, &c, "yxf", "ㄔㄨˊ");
  checkEq(&container, &c, "yxj", "ㄔㄨˇ");
  checkEq(&container, &c, "yxk", "ㄔㄨˋ");
  checkEq(&container, &c, "yxa", "ㄔㄨㄚ");
  checkEq(&container, &c, "yxaj", "ㄔㄨㄚˇ");
  checkEq(&container, &c, "yxak", "ㄔㄨㄚˋ");
  checkEq(&container, &c, "yxo", "ㄔㄨㄛ");
  checkEq(&container, &c, "yxok", "ㄔㄨㄛˋ");
  checkEq(&container, &c, "yxi", "ㄔㄨㄞ");
  checkEq(&container, &c, "yxif", "ㄔㄨㄞˊ");
  checkEq(&container, &c, "yxij", "ㄔㄨㄞˇ");
  checkEq(&container, &c, "yxik", "ㄔㄨㄞˋ");
  checkEq(&container, &c, "yxq", "ㄔㄨㄟ");
  checkEq(&container, &c, "yxqf", "ㄔㄨㄟˊ");
  checkEq(&container, &c, "yxqj", "ㄔㄨㄟˇ");
  checkEq(&container, &c, "yxqk", "ㄔㄨㄟˋ");
  checkEq(&container, &c, "yxm", "ㄔㄨㄢ");
  checkEq(&container, &c, "yxmf", "ㄔㄨㄢˊ");
  checkEq(&container, &c, "yxmj", "ㄔㄨㄢˇ");
  checkEq(&container, &c, "yxmk", "ㄔㄨㄢˋ");
  checkEq(&container, &c, "yxn", "ㄔㄨㄣ");
  checkEq(&container, &c, "yxnf", "ㄔㄨㄣˊ");
  checkEq(&container, &c, "yxnj", "ㄔㄨㄣˇ");
  checkEq(&container, &c, "yxt", "ㄔㄨㄤ");
  checkEq(&container, &c, "yxtf", "ㄔㄨㄤˊ");
  checkEq(&container, &c, "yxtj", "ㄔㄨㄤˇ");
  checkEq(&container, &c, "yxtk", "ㄔㄨㄤˋ");
  checkEq(&container, &c, "yxl", "ㄔㄨㄥ");
  checkEq(&container, &c, "yxlf", "ㄔㄨㄥˊ");
  checkEq(&container, &c, "yxlj", "ㄔㄨㄥˇ");
  checkEq(&container, &c, "yxlk", "ㄔㄨㄥˋ");
  checkEq(&container, &c, "c", "ㄕ");
  checkEq(&container, &c, "cf", "ㄕˊ");
  checkEq(&container, &c, "cj", "ㄕˇ");
  checkEq(&container, &c, "ck", "ㄕˋ");
  checkEq(&container, &c, "cd", "ㄕ˙");
  checkEq(&container, &c, "ca", "ㄕㄚ");
  checkEq(&container, &c, "caf", "ㄕㄚˊ");
  checkEq(&container, &c, "caj", "ㄕㄚˇ");
  checkEq(&container, &c, "cak", "ㄕㄚˋ");
  checkEq(&container, &c, "cad", "ㄕㄚ˙");
  checkEq(&container, &c, "cr", "ㄕㄜ");
  checkEq(&container, &c, "crf", "ㄕㄜˊ");
  checkEq(&container, &c, "crj", "ㄕㄜˇ");
  checkEq(&container, &c, "crk", "ㄕㄜˋ");
  checkEq(&container, &c, "ci", "ㄕㄞ");
  checkEq(&container, &c, "cij", "ㄕㄞˇ");
  checkEq(&container, &c, "cik", "ㄕㄞˋ");
  checkEq(&container, &c, "cqf", "ㄕㄟˊ");
  checkEq(&container, &c, "cz", "ㄕㄠ");
  checkEq(&container, &c, "czf", "ㄕㄠˊ");
  checkEq(&container, &c, "czj", "ㄕㄠˇ");
  checkEq(&container, &c, "czk", "ㄕㄠˋ");
  checkEq(&container, &c, "cp", "ㄕㄡ");
  checkEq(&container, &c, "cpf", "ㄕㄡˊ");
  checkEq(&container, &c, "cpj", "ㄕㄡˇ");
  checkEq(&container, &c, "cpk", "ㄕㄡˋ");
  checkEq(&container, &c, "cm", "ㄕㄢ");
  checkEq(&container, &c, "cmf", "ㄕㄢˊ");
  checkEq(&container, &c, "cmj", "ㄕㄢˇ");
  checkEq(&container, &c, "cmk", "ㄕㄢˋ");
  checkEq(&container, &c, "cn", "ㄕㄣ");
  checkEq(&container, &c, "cnf", "ㄕㄣˊ");
  checkEq(&container, &c, "cnj", "ㄕㄣˇ");
  checkEq(&container, &c, "cnk", "ㄕㄣˋ");
  checkEq(&container, &c, "ct", "ㄕㄤ");
  checkEq(&container, &c, "ctj", "ㄕㄤˇ");
  checkEq(&container, &c, "ctk", "ㄕㄤˋ");
  checkEq(&container, &c, "ctd", "ㄕㄤ˙");
  checkEq(&container, &c, "cl", "ㄕㄥ");
  checkEq(&container, &c, "clf", "ㄕㄥˊ");
  checkEq(&container, &c, "clj", "ㄕㄥˇ");
  checkEq(&container, &c, "clk", "ㄕㄥˋ");
  checkEq(&container, &c, "cx", "ㄕㄨ");
  checkEq(&container, &c, "cxf", "ㄕㄨˊ");
  checkEq(&container, &c, "cxj", "ㄕㄨˇ");
  checkEq(&container, &c, "cxk", "ㄕㄨˋ");
  checkEq(&container, &c, "cxa", "ㄕㄨㄚ");
  checkEq(&container, &c, "cxaj", "ㄕㄨㄚˇ");
  checkEq(&container, &c, "cxak", "ㄕㄨㄚˋ");
  checkEq(&container, &c, "cxo", "ㄕㄨㄛ");
  checkEq(&container, &c, "cxok", "ㄕㄨㄛˋ");
  checkEq(&container, &c, "cxi", "ㄕㄨㄞ");
  checkEq(&container, &c, "cxij", "ㄕㄨㄞˇ");
  checkEq(&container, &c, "cxik", "ㄕㄨㄞˋ");
  checkEq(&container, &c, "cxq", "ㄕㄨㄟ");
  checkEq(&container, &c, "cxqf", "ㄕㄨㄟˊ");
  checkEq(&container, &c, "cxqj", "ㄕㄨㄟˇ");
  checkEq(&container, &c, "cxqk", "ㄕㄨㄟˋ");
  checkEq(&container, &c, "cxm", "ㄕㄨㄢ");
  checkEq(&container, &c, "cxmk", "ㄕㄨㄢˋ");
  checkEq(&container, &c, "cxnj", "ㄕㄨㄣˇ");
  checkEq(&container, &c, "cxnk", "ㄕㄨㄣˋ");
  checkEq(&container, &c, "cxt", "ㄕㄨㄤ");
  checkEq(&container, &c, "cxtf", "ㄕㄨㄤˊ");
  checkEq(&container, &c, "cxtj", "ㄕㄨㄤˇ");
  checkEq(&container, &c, "cxtk", "ㄕㄨㄤˋ");
  checkEq(&container, &c, "jk", "ㄖˋ");
  checkEq(&container, &c, "jrj", "ㄖㄜˇ");
  checkEq(&container, &c, "jrk", "ㄖㄜˋ");
  checkEq(&container, &c, "jzf", "ㄖㄠˊ");
  checkEq(&container, &c, "jzj", "ㄖㄠˇ");
  checkEq(&container, &c, "jzk", "ㄖㄠˋ");
  checkEq(&container, &c, "jpf", "ㄖㄡˊ");
  checkEq(&container, &c, "jpj", "ㄖㄡˇ");
  checkEq(&container, &c, "jpk", "ㄖㄡˋ");
  checkEq(&container, &c, "jmf", "ㄖㄢˊ");
  checkEq(&container, &c, "jmj", "ㄖㄢˇ");
  checkEq(&container, &c, "jmk", "ㄖㄢˋ");
  checkEq(&container, &c, "jnf", "ㄖㄣˊ");
  checkEq(&container, &c, "jnj", "ㄖㄣˇ");
  checkEq(&container, &c, "jnk", "ㄖㄣˋ");
  checkEq(&container, &c, "jt", "ㄖㄤ");
  checkEq(&container, &c, "jtf", "ㄖㄤˊ");
  checkEq(&container, &c, "jtj", "ㄖㄤˇ");
  checkEq(&container, &c, "jtk", "ㄖㄤˋ");
  checkEq(&container, &c, "jl", "ㄖㄥ");
  checkEq(&container, &c, "jlf", "ㄖㄥˊ");
  checkEq(&container, &c, "jlj", "ㄖㄥˇ");
  checkEq(&container, &c, "jlk", "ㄖㄥˋ");
  checkEq(&container, &c, "jxf", "ㄖㄨˊ");
  checkEq(&container, &c, "jxj", "ㄖㄨˇ");
  checkEq(&container, &c, "jxk", "ㄖㄨˋ");
  checkEq(&container, &c, "jxof", "ㄖㄨㄛˊ");
  checkEq(&container, &c, "jxok", "ㄖㄨㄛˋ");
  checkEq(&container, &c, "jxqf", "ㄖㄨㄟˊ");
  checkEq(&container, &c, "jxqj", "ㄖㄨㄟˇ");
  checkEq(&container, &c, "jxqk", "ㄖㄨㄟˋ");
  checkEq(&container, &c, "jxmf", "ㄖㄨㄢˊ");
  checkEq(&container, &c, "jxmj", "ㄖㄨㄢˇ");
  checkEq(&container, &c, "jxmk", "ㄖㄨㄢˋ");
  checkEq(&container, &c, "jxnf", "ㄖㄨㄣˊ");
  checkEq(&container, &c, "jxnj", "ㄖㄨㄣˇ");
  checkEq(&container, &c, "jxnk", "ㄖㄨㄣˋ");
  checkEq(&container, &c, "jxlf", "ㄖㄨㄥˊ");
  checkEq(&container, &c, "jxlj", "ㄖㄨㄥˇ");
  checkEq(&container, &c, "jxlk", "ㄖㄨㄥˋ");
  checkEq(&container, &c, "q", "ㄗ");
  checkEq(&container, &c, "qf", "ㄗˊ");
  checkEq(&container, &c, "qj", "ㄗˇ");
  checkEq(&container, &c, "qk", "ㄗˋ");
  checkEq(&container, &c, "qd", "ㄗ˙");
  checkEq(&container, &c, "qa", "ㄗㄚ");
  checkEq(&container, &c, "qaf", "ㄗㄚˊ");
  checkEq(&container, &c, "qaj", "ㄗㄚˇ");
  checkEq(&container, &c, "qrf", "ㄗㄜˊ");
  checkEq(&container, &c, "qrj", "ㄗㄜˇ");
  checkEq(&container, &c, "qrk", "ㄗㄜˋ");
  checkEq(&container, &c, "qi", "ㄗㄞ");
  checkEq(&container, &c, "qij", "ㄗㄞˇ");
  checkEq(&container, &c, "qik", "ㄗㄞˋ");
  checkEq(&container, &c, "qqf", "ㄗㄟˊ");
  checkEq(&container, &c, "qz", "ㄗㄠ");
  checkEq(&container, &c, "qzf", "ㄗㄠˊ");
  checkEq(&container, &c, "qzj", "ㄗㄠˇ");
  checkEq(&container, &c, "qzk", "ㄗㄠˋ");
  checkEq(&container, &c, "qp", "ㄗㄡ");
  checkEq(&container, &c, "qpj", "ㄗㄡˇ");
  checkEq(&container, &c, "qpk", "ㄗㄡˋ");
  checkEq(&container, &c, "qm", "ㄗㄢ");
  checkEq(&container, &c, "qmf", "ㄗㄢˊ");
  checkEq(&container, &c, "qmj", "ㄗㄢˇ");
  checkEq(&container, &c, "qmk", "ㄗㄢˋ");
  checkEq(&container, &c, "qn", "ㄗㄣ");
  checkEq(&container, &c, "qnj", "ㄗㄣˇ");
  checkEq(&container, &c, "qnk", "ㄗㄣˋ");
  checkEq(&container, &c, "qt", "ㄗㄤ");
  checkEq(&container, &c, "qtj", "ㄗㄤˇ");
  checkEq(&container, &c, "qtk", "ㄗㄤˋ");
  checkEq(&container, &c, "ql", "ㄗㄥ");
  checkEq(&container, &c, "qlj", "ㄗㄥˇ");
  checkEq(&container, &c, "qlk", "ㄗㄥˋ");
  checkEq(&container, &c, "qx", "ㄗㄨ");
  checkEq(&container, &c, "qxf", "ㄗㄨˊ");
  checkEq(&container, &c, "qxj", "ㄗㄨˇ");
  checkEq(&container, &c, "qxk", "ㄗㄨˋ");
  checkEq(&container, &c, "qxo", "ㄗㄨㄛ");
  checkEq(&container, &c, "qxof", "ㄗㄨㄛˊ");
  checkEq(&container, &c, "qxoj", "ㄗㄨㄛˇ");
  checkEq(&container, &c, "qxok", "ㄗㄨㄛˋ");
  checkEq(&container, &c, "qxod", "ㄗㄨㄛ˙");
  checkEq(&container, &c, "qxq", "ㄗㄨㄟ");
  checkEq(&container, &c, "qxqj", "ㄗㄨㄟˇ");
  checkEq(&container, &c, "qxqk", "ㄗㄨㄟˋ");
  checkEq(&container, &c, "qxm", "ㄗㄨㄢ");
  checkEq(&container, &c, "qxmj", "ㄗㄨㄢˇ");
  checkEq(&container, &c, "qxmk", "ㄗㄨㄢˋ");
  checkEq(&container, &c, "qxn", "ㄗㄨㄣ");
  checkEq(&container, &c, "qxnj", "ㄗㄨㄣˇ");
  checkEq(&container, &c, "qxnk", "ㄗㄨㄣˋ");
  checkEq(&container, &c, "qxl", "ㄗㄨㄥ");
  checkEq(&container, &c, "qxlj", "ㄗㄨㄥˇ");
  checkEq(&container, &c, "qxlk", "ㄗㄨㄥˋ");
  checkEq(&container, &c, "w", "ㄘ");
  checkEq(&container, &c, "wf", "ㄘˊ");
  checkEq(&container, &c, "wj", "ㄘˇ");
  checkEq(&container, &c, "wk", "ㄘˋ");
  checkEq(&container, &c, "wa", "ㄘㄚ");
  checkEq(&container, &c, "waj", "ㄘㄚˇ");
  checkEq(&container, &c, "wak", "ㄘㄚˋ");
  checkEq(&container, &c, "wrk", "ㄘㄜˋ");
  checkEq(&container, &c, "wi", "ㄘㄞ");
  checkEq(&container, &c, "wif", "ㄘㄞˊ");
  checkEq(&container, &c, "wij", "ㄘㄞˇ");
  checkEq(&container, &c, "wik", "ㄘㄞˋ");
  checkEq(&container, &c, "wz", "ㄘㄠ");
  checkEq(&container, &c, "wzf", "ㄘㄠˊ");
  checkEq(&container, &c, "wzj", "ㄘㄠˇ");
  checkEq(&container, &c, "wzk", "ㄘㄠˋ");
  checkEq(&container, &c, "wp", "ㄘㄡ");
  checkEq(&container, &c, "wpf", "ㄘㄡˊ");
  checkEq(&container, &c, "wpj", "ㄘㄡˇ");
  checkEq(&container, &c, "wpk", "ㄘㄡˋ");
  checkEq(&container, &c, "wm", "ㄘㄢ");
  checkEq(&container, &c, "wmf", "ㄘㄢˊ");
  checkEq(&container, &c, "wmj", "ㄘㄢˇ");
  checkEq(&container, &c, "wmk", "ㄘㄢˋ");
  checkEq(&container, &c, "wn", "ㄘㄣ");
  checkEq(&container, &c, "wnf", "ㄘㄣˊ");
  checkEq(&container, &c, "wt", "ㄘㄤ");
  checkEq(&container, &c, "wtf", "ㄘㄤˊ");
  checkEq(&container, &c, "wtj", "ㄘㄤˇ");
  checkEq(&container, &c, "wtk", "ㄘㄤˋ");
  checkEq(&container, &c, "wl", "ㄘㄥ");
  checkEq(&container, &c, "wlf", "ㄘㄥˊ");
  checkEq(&container, &c, "wlj", "ㄘㄥˇ");
  checkEq(&container, &c, "wlk", "ㄘㄥˋ");
  checkEq(&container, &c, "wx", "ㄘㄨ");
  checkEq(&container, &c, "wxf", "ㄘㄨˊ");
  checkEq(&container, &c, "wxj", "ㄘㄨˇ");
  checkEq(&container, &c, "wxk", "ㄘㄨˋ");
  checkEq(&container, &c, "wxo", "ㄘㄨㄛ");
  checkEq(&container, &c, "wxof", "ㄘㄨㄛˊ");
  checkEq(&container, &c, "wxoj", "ㄘㄨㄛˇ");
  checkEq(&container, &c, "wxok", "ㄘㄨㄛˋ");
  checkEq(&container, &c, "wxq", "ㄘㄨㄟ");
  checkEq(&container, &c, "wxqj", "ㄘㄨㄟˇ");
  checkEq(&container, &c, "wxqk", "ㄘㄨㄟˋ");
  checkEq(&container, &c, "wxm", "ㄘㄨㄢ");
  checkEq(&container, &c, "wxmf", "ㄘㄨㄢˊ");
  checkEq(&container, &c, "wxmj", "ㄘㄨㄢˇ");
  checkEq(&container, &c, "wxmk", "ㄘㄨㄢˋ");
  checkEq(&container, &c, "wxn", "ㄘㄨㄣ");
  checkEq(&container, &c, "wxnf", "ㄘㄨㄣˊ");
  checkEq(&container, &c, "wxnj", "ㄘㄨㄣˇ");
  checkEq(&container, &c, "wxnk", "ㄘㄨㄣˋ");
  checkEq(&container, &c, "wxl", "ㄘㄨㄥ");
  checkEq(&container, &c, "wxlf", "ㄘㄨㄥˊ");
  checkEq(&container, &c, "wxlj", "ㄘㄨㄥˇ");
  checkEq(&container, &c, "wxlk", "ㄘㄨㄥˋ");
  checkEq(&container, &c, "s", "ㄙ");
  checkEq(&container, &c, "sj", "ㄙˇ");
  checkEq(&container, &c, "sk", "ㄙˋ");
  checkEq(&container, &c, "sa", "ㄙㄚ");
  checkEq(&container, &c, "saj", "ㄙㄚˇ");
  checkEq(&container, &c, "sak", "ㄙㄚˋ");
  checkEq(&container, &c, "sad", "ㄙㄚ˙");
  checkEq(&container, &c, "sr", "ㄙㄜ");
  checkEq(&container, &c, "srk", "ㄙㄜˋ");
  checkEq(&container, &c, "si", "ㄙㄞ");
  checkEq(&container, &c, "sif", "ㄙㄞˊ");
  checkEq(&container, &c, "sij", "ㄙㄞˇ");
  checkEq(&container, &c, "sik", "ㄙㄞˋ");
  checkEq(&container, &c, "sq", "ㄙㄟ");
  checkEq(&container, &c, "sz", "ㄙㄠ");
  checkEq(&container, &c, "szj", "ㄙㄠˇ");
  checkEq(&container, &c, "szk", "ㄙㄠˋ");
  checkEq(&container, &c, "sp", "ㄙㄡ");
  checkEq(&container, &c, "spj", "ㄙㄡˇ");
  checkEq(&container, &c, "spk", "ㄙㄡˋ");
  checkEq(&container, &c, "sm", "ㄙㄢ");
  checkEq(&container, &c, "smj", "ㄙㄢˇ");
  checkEq(&container, &c, "smk", "ㄙㄢˋ");
  checkEq(&container, &c, "sn", "ㄙㄣ");
  checkEq(&container, &c, "snj", "ㄙㄣˇ");
  checkEq(&container, &c, "st", "ㄙㄤ");
  checkEq(&container, &c, "stj", "ㄙㄤˇ");
  checkEq(&container, &c, "stk", "ㄙㄤˋ");
  checkEq(&container, &c, "sl", "ㄙㄥ");
  checkEq(&container, &c, "slk", "ㄙㄥˋ");
  checkEq(&container, &c, "sx", "ㄙㄨ");
  checkEq(&container, &c, "sxf", "ㄙㄨˊ");
  checkEq(&container, &c, "sxj", "ㄙㄨˇ");
  checkEq(&container, &c, "sxk", "ㄙㄨˋ");
  checkEq(&container, &c, "sxo", "ㄙㄨㄛ");
  checkEq(&container, &c, "sxof", "ㄙㄨㄛˊ");
  checkEq(&container, &c, "sxoj", "ㄙㄨㄛˇ");
  checkEq(&container, &c, "sxok", "ㄙㄨㄛˋ");
  checkEq(&container, &c, "sxq", "ㄙㄨㄟ");
  checkEq(&container, &c, "sxqf", "ㄙㄨㄟˊ");
  checkEq(&container, &c, "sxqj", "ㄙㄨㄟˇ");
  checkEq(&container, &c, "sxqk", "ㄙㄨㄟˋ");
  checkEq(&container, &c, "sxm", "ㄙㄨㄢ");
  checkEq(&container, &c, "sxmj", "ㄙㄨㄢˇ");
  checkEq(&container, &c, "sxmk", "ㄙㄨㄢˋ");
  checkEq(&container, &c, "sxn", "ㄙㄨㄣ");
  checkEq(&container, &c, "sxnj", "ㄙㄨㄣˇ");
  checkEq(&container, &c, "sxnk", "ㄙㄨㄣˋ");
  checkEq(&container, &c, "sxl", "ㄙㄨㄥ");
  checkEq(&container, &c, "sxlf", "ㄙㄨㄥˊ");
  checkEq(&container, &c, "sxlj", "ㄙㄨㄥˇ");
  checkEq(&container, &c, "sxlk", "ㄙㄨㄥˋ");
  checkEq(&container, &c, "a", "ㄚ");
  checkEq(&container, &c, "af", "ㄚˊ");
  checkEq(&container, &c, "ak", "ㄚˋ");
  checkEq(&container, &c, "ad", "ㄚ˙");
  checkEq(&container, &c, "o", "ㄛ");
  checkEq(&container, &c, "of", "ㄛˊ");
  checkEq(&container, &c, "oj", "ㄛˇ");
  checkEq(&container, &c, "ok", "ㄛˋ");
  checkEq(&container, &c, "r", "ㄜ");
  checkEq(&container, &c, "rf", "ㄜˊ");
  checkEq(&container, &c, "rj", "ㄜˇ");
  checkEq(&container, &c, "rk", "ㄜˋ");
  // checkEq(&container, &c, "wf", "ㄝˊ");
  // checkEq(&container, &c, "wj", "ㄝˇ");
  // checkEq(&container, &c, "wk", "ㄝˋ");
  // checkEq(&container, &c, "wd", "ㄝ˙");
  checkEq(&container, &c, "i", "ㄞ");
  checkEq(&container, &c, "if", "ㄞˊ");
  checkEq(&container, &c, "ij", "ㄞˇ");
  checkEq(&container, &c, "ik", "ㄞˋ");
  // checkEq(&container, &c, "qk", "ㄟˋ");
  checkEq(&container, &c, "z", "ㄠ");
  checkEq(&container, &c, "zf", "ㄠˊ");
  checkEq(&container, &c, "zj", "ㄠˇ");
  checkEq(&container, &c, "zk", "ㄠˋ");
  checkEq(&container, &c, "p ", "ㄡ ");
  checkEq(&container, &c, "pf", "ㄡˊ");
  checkEq(&container, &c, "pj", "ㄡˇ");
  checkEq(&container, &c, "pk", "ㄡˋ");
  checkEq(&container, &c, "pd", "ㄡ˙");
  checkEq(&container, &c, "m ", "ㄢ ");
  checkEq(&container, &c, "mf", "ㄢˊ");
  checkEq(&container, &c, "mj", "ㄢˇ");
  checkEq(&container, &c, "mk", "ㄢˋ");
  checkEq(&container, &c, "n ", "ㄣ ");
  checkEq(&container, &c, "nf", "ㄣˊ");
  checkEq(&container, &c, "nj", "ㄣˇ");
  checkEq(&container, &c, "nk", "ㄣˋ");
  checkEq(&container, &c, "nd", "ㄣ˙");
  checkEq(&container, &c, "t ", "ㄤ ");
  checkEq(&container, &c, "tf", "ㄤˊ");
  checkEq(&container, &c, "tj", "ㄤˇ");
  checkEq(&container, &c, "tk", "ㄤˋ");
  checkEq(&container, &c, "l ", "ㄥ ");
  checkEq(&container, &c, "lk", "ㄥˋ");
  checkEq(&container, &c, "h ", "ㄦ ");
  checkEq(&container, &c, "hf", "ㄦˊ");
  checkEq(&container, &c, "hj", "ㄦˇ");
  checkEq(&container, &c, "hk", "ㄦˋ");
  checkEq(&container, &c, "hd", "ㄦ˙");
  checkEq(&container, &c, "e", "ㄧ");
  checkEq(&container, &c, "ef", "ㄧˊ");
  checkEq(&container, &c, "ej", "ㄧˇ");
  checkEq(&container, &c, "ek", "ㄧˋ");
  checkEq(&container, &c, "ea", "ㄧㄚ");
  checkEq(&container, &c, "eaf", "ㄧㄚˊ");
  checkEq(&container, &c, "eaj", "ㄧㄚˇ");
  checkEq(&container, &c, "eak", "ㄧㄚˋ");
  checkEq(&container, &c, "ead", "ㄧㄚ˙");
  checkEq(&container, &c, "eo", "ㄧㄛ");
  checkEq(&container, &c, "eod", "ㄧㄛ˙");
  checkEq(&container, &c, "ew", "ㄧㄝ");
  checkEq(&container, &c, "ewf", "ㄧㄝˊ");
  checkEq(&container, &c, "ewj", "ㄧㄝˇ");
  checkEq(&container, &c, "ewk", "ㄧㄝˋ");
  checkEq(&container, &c, "ewd", "ㄧㄝ˙");
  checkEq(&container, &c, "eif", "ㄧㄞˊ");
  checkEq(&container, &c, "ez", "ㄧㄠ");
  checkEq(&container, &c, "ezf", "ㄧㄠˊ");
  checkEq(&container, &c, "ezj", "ㄧㄠˇ");
  checkEq(&container, &c, "ezk", "ㄧㄠˋ");
  checkEq(&container, &c, "ep", "ㄧㄡ");
  checkEq(&container, &c, "epf", "ㄧㄡˊ");
  checkEq(&container, &c, "epj", "ㄧㄡˇ");
  checkEq(&container, &c, "epk", "ㄧㄡˋ");
  checkEq(&container, &c, "em", "ㄧㄢ");
  checkEq(&container, &c, "emf", "ㄧㄢˊ");
  checkEq(&container, &c, "emj", "ㄧㄢˇ");
  checkEq(&container, &c, "emk", "ㄧㄢˋ");
  checkEq(&container, &c, "en", "ㄧㄣ");
  checkEq(&container, &c, "enf", "ㄧㄣˊ");
  checkEq(&container, &c, "enj", "ㄧㄣˇ");
  checkEq(&container, &c, "enk", "ㄧㄣˋ");
  checkEq(&container, &c, "et", "ㄧㄤ");
  checkEq(&container, &c, "etf", "ㄧㄤˊ");
  checkEq(&container, &c, "etj", "ㄧㄤˇ");
  checkEq(&container, &c, "etk", "ㄧㄤˋ");
  checkEq(&container, &c, "el", "ㄧㄥ");
  checkEq(&container, &c, "elf", "ㄧㄥˊ");
  checkEq(&container, &c, "elj", "ㄧㄥˇ");
  checkEq(&container, &c, "elk", "ㄧㄥˋ");
  checkEq(&container, &c, "x", "ㄨ");
  checkEq(&container, &c, "xf", "ㄨˊ");
  checkEq(&container, &c, "xj", "ㄨˇ");
  checkEq(&container, &c, "xk", "ㄨˋ");
  checkEq(&container, &c, "xa", "ㄨㄚ");
  checkEq(&container, &c, "xaf", "ㄨㄚˊ");
  checkEq(&container, &c, "xaj", "ㄨㄚˇ");
  checkEq(&container, &c, "xak", "ㄨㄚˋ");
  checkEq(&container, &c, "xad", "ㄨㄚ˙");
  checkEq(&container, &c, "xo", "ㄨㄛ");
  checkEq(&container, &c, "xoj", "ㄨㄛˇ");
  checkEq(&container, &c, "xok", "ㄨㄛˋ");
  checkEq(&container, &c, "xi", "ㄨㄞ");
  checkEq(&container, &c, "xij", "ㄨㄞˇ");
  checkEq(&container, &c, "xik", "ㄨㄞˋ");
  checkEq(&container, &c, "xq", "ㄨㄟ");
  checkEq(&container, &c, "xqf", "ㄨㄟˊ");
  checkEq(&container, &c, "xqj", "ㄨㄟˇ");
  checkEq(&container, &c, "xqk", "ㄨㄟˋ");
  checkEq(&container, &c, "xm", "ㄨㄢ");
  checkEq(&container, &c, "xmf", "ㄨㄢˊ");
  checkEq(&container, &c, "xmj", "ㄨㄢˇ");
  checkEq(&container, &c, "xmk", "ㄨㄢˋ");
  checkEq(&container, &c, "xn", "ㄨㄣ");
  checkEq(&container, &c, "xnf", "ㄨㄣˊ");
  checkEq(&container, &c, "xnj", "ㄨㄣˇ");
  checkEq(&container, &c, "xnk", "ㄨㄣˋ");
  checkEq(&container, &c, "xt", "ㄨㄤ");
  checkEq(&container, &c, "xtf", "ㄨㄤˊ");
  checkEq(&container, &c, "xtj", "ㄨㄤˇ");
  checkEq(&container, &c, "xtk", "ㄨㄤˋ");
  checkEq(&container, &c, "xl", "ㄨㄥ");
  checkEq(&container, &c, "xlj", "ㄨㄥˇ");
  checkEq(&container, &c, "xlk", "ㄨㄥˋ");
  checkEq(&container, &c, "u", "ㄩ");
  checkEq(&container, &c, "uf", "ㄩˊ");
  checkEq(&container, &c, "uj", "ㄩˇ");
  checkEq(&container, &c, "uk", "ㄩˋ");
  checkEq(&container, &c, "uw", "ㄩㄝ");
  checkEq(&container, &c, "uwj", "ㄩㄝˇ");
  checkEq(&container, &c, "uwk", "ㄩㄝˋ");
  checkEq(&container, &c, "um", "ㄩㄢ");
  checkEq(&container, &c, "umf", "ㄩㄢˊ");
  checkEq(&container, &c, "umj", "ㄩㄢˇ");
  checkEq(&container, &c, "umk", "ㄩㄢˋ");
  checkEq(&container, &c, "un", "ㄩㄣ");
  checkEq(&container, &c, "unf", "ㄩㄣˊ");
  checkEq(&container, &c, "unj", "ㄩㄣˇ");
  checkEq(&container, &c, "unk", "ㄩㄣˋ");
  checkEq(&container, &c, "ul", "ㄩㄥ");
  checkEq(&container, &c, "ulf", "ㄩㄥˊ");
  checkEq(&container, &c, "ulj", "ㄩㄥˇ");
  checkEq(&container, &c, "ulk", "ㄩㄥˋ");
  ASSERT_TRUE(container.empty());
}

TEST(TekkonTests_Advanced, HsuKeys) {
  // Testing handleHsu()
  Composer c = Composer("", ofHsu);
  std::vector<std::string> container = {};
  checkEq(&container, &c, "kek", "ㄎㄧㄤ");
  checkEq(&container, &c, "gewd", "ㄍㄧㄠˊ");
  checkEq(&container, &c, "gen", "ㄍㄧㄣ");
  checkEq(&container, &c, "bekd", "ㄅㄧㄤˊ");
  checkEq(&container, &c, "bekj", "ㄅㄧㄤˋ");
  checkEq(&container, &c, "dxk", "ㄉㄨㄤ");
  checkEq(&container, &c, "by", "ㄅㄚ");
  checkEq(&container, &c, "byd", "ㄅㄚˊ");
  checkEq(&container, &c, "byf", "ㄅㄚˇ");
  checkEq(&container, &c, "byj", "ㄅㄚˋ");
  checkEq(&container, &c, "bys", "ㄅㄚ˙");
  checkEq(&container, &c, "bh", "ㄅㄛ");
  checkEq(&container, &c, "bhd", "ㄅㄛˊ");
  checkEq(&container, &c, "bhf", "ㄅㄛˇ");
  checkEq(&container, &c, "bhj", "ㄅㄛˋ");
  checkEq(&container, &c, "bhs", "ㄅㄛ˙");
  checkEq(&container, &c, "bi", "ㄅㄞ");
  checkEq(&container, &c, "bid", "ㄅㄞˊ");
  checkEq(&container, &c, "bif", "ㄅㄞˇ");
  checkEq(&container, &c, "bij", "ㄅㄞˋ");
  checkEq(&container, &c, "bis", "ㄅㄞ˙");
  checkEq(&container, &c, "ba", "ㄅㄟ");
  checkEq(&container, &c, "baf", "ㄅㄟˇ");
  checkEq(&container, &c, "baj", "ㄅㄟˋ");
  checkEq(&container, &c, "bas", "ㄅㄟ˙");
  checkEq(&container, &c, "bw", "ㄅㄠ");
  checkEq(&container, &c, "bwd", "ㄅㄠˊ");
  checkEq(&container, &c, "bwf", "ㄅㄠˇ");
  checkEq(&container, &c, "bwj", "ㄅㄠˋ");
  checkEq(&container, &c, "bm", "ㄅㄢ");
  checkEq(&container, &c, "bmf", "ㄅㄢˇ");
  checkEq(&container, &c, "bmj", "ㄅㄢˋ");
  checkEq(&container, &c, "bn", "ㄅㄣ");
  checkEq(&container, &c, "bnf", "ㄅㄣˇ");
  checkEq(&container, &c, "bnj", "ㄅㄣˋ");
  checkEq(&container, &c, "bk", "ㄅㄤ");
  checkEq(&container, &c, "bkf", "ㄅㄤˇ");
  checkEq(&container, &c, "bkj", "ㄅㄤˋ");
  checkEq(&container, &c, "bl", "ㄅㄥ");
  checkEq(&container, &c, "bld", "ㄅㄥˊ");
  checkEq(&container, &c, "blf", "ㄅㄥˇ");
  checkEq(&container, &c, "blj", "ㄅㄥˋ");
  checkEq(&container, &c, "be", "ㄅㄧ");
  checkEq(&container, &c, "bed", "ㄅㄧˊ");
  checkEq(&container, &c, "bef", "ㄅㄧˇ");
  checkEq(&container, &c, "bej", "ㄅㄧˋ");
  checkEq(&container, &c, "bee", "ㄅㄧㄝ");
  checkEq(&container, &c, "beed", "ㄅㄧㄝˊ");
  checkEq(&container, &c, "beef", "ㄅㄧㄝˇ");
  checkEq(&container, &c, "beej", "ㄅㄧㄝˋ");
  checkEq(&container, &c, "bew", "ㄅㄧㄠ");
  checkEq(&container, &c, "bewf", "ㄅㄧㄠˇ");
  checkEq(&container, &c, "bewj", "ㄅㄧㄠˋ");
  checkEq(&container, &c, "bem", "ㄅㄧㄢ");
  checkEq(&container, &c, "bemd", "ㄅㄧㄢˊ");
  checkEq(&container, &c, "bemf", "ㄅㄧㄢˇ");
  checkEq(&container, &c, "bemj", "ㄅㄧㄢˋ");
  checkEq(&container, &c, "ben", "ㄅㄧㄣ");
  checkEq(&container, &c, "benf", "ㄅㄧㄣˇ");
  checkEq(&container, &c, "benj", "ㄅㄧㄣˋ");
  checkEq(&container, &c, "bel", "ㄅㄧㄥ");
  checkEq(&container, &c, "belf", "ㄅㄧㄥˇ");
  checkEq(&container, &c, "belj", "ㄅㄧㄥˋ");
  checkEq(&container, &c, "bx", "ㄅㄨ");
  checkEq(&container, &c, "bxd", "ㄅㄨˊ");
  checkEq(&container, &c, "bxf", "ㄅㄨˇ");
  checkEq(&container, &c, "bxj", "ㄅㄨˋ");
  checkEq(&container, &c, "py", "ㄆㄚ");
  checkEq(&container, &c, "pyd", "ㄆㄚˊ");
  checkEq(&container, &c, "pyf", "ㄆㄚˇ");
  checkEq(&container, &c, "pyj", "ㄆㄚˋ");
  checkEq(&container, &c, "pys", "ㄆㄚ˙");
  checkEq(&container, &c, "ph", "ㄆㄛ");
  checkEq(&container, &c, "phd", "ㄆㄛˊ");
  checkEq(&container, &c, "phf", "ㄆㄛˇ");
  checkEq(&container, &c, "phj", "ㄆㄛˋ");
  checkEq(&container, &c, "pi", "ㄆㄞ");
  checkEq(&container, &c, "pid", "ㄆㄞˊ");
  checkEq(&container, &c, "pif", "ㄆㄞˇ");
  checkEq(&container, &c, "pij", "ㄆㄞˋ");
  checkEq(&container, &c, "pa", "ㄆㄟ");
  checkEq(&container, &c, "pad", "ㄆㄟˊ");
  checkEq(&container, &c, "paf", "ㄆㄟˇ");
  checkEq(&container, &c, "paj", "ㄆㄟˋ");
  checkEq(&container, &c, "pw", "ㄆㄠ");
  checkEq(&container, &c, "pwd", "ㄆㄠˊ");
  checkEq(&container, &c, "pwf", "ㄆㄠˇ");
  checkEq(&container, &c, "pwj", "ㄆㄠˋ");
  checkEq(&container, &c, "po", "ㄆㄡ");
  checkEq(&container, &c, "pod", "ㄆㄡˊ");
  checkEq(&container, &c, "pof", "ㄆㄡˇ");
  checkEq(&container, &c, "poj", "ㄆㄡˋ");
  checkEq(&container, &c, "pm", "ㄆㄢ");
  checkEq(&container, &c, "pmd", "ㄆㄢˊ");
  checkEq(&container, &c, "pmf", "ㄆㄢˇ");
  checkEq(&container, &c, "pmj", "ㄆㄢˋ");
  checkEq(&container, &c, "pn", "ㄆㄣ");
  checkEq(&container, &c, "pnd", "ㄆㄣˊ");
  checkEq(&container, &c, "pnf", "ㄆㄣˇ");
  checkEq(&container, &c, "pnj", "ㄆㄣˋ");
  checkEq(&container, &c, "pk", "ㄆㄤ");
  checkEq(&container, &c, "pkd", "ㄆㄤˊ");
  checkEq(&container, &c, "pkf", "ㄆㄤˇ");
  checkEq(&container, &c, "pkj", "ㄆㄤˋ");
  checkEq(&container, &c, "pl", "ㄆㄥ");
  checkEq(&container, &c, "pld", "ㄆㄥˊ");
  checkEq(&container, &c, "plf", "ㄆㄥˇ");
  checkEq(&container, &c, "plj", "ㄆㄥˋ");
  checkEq(&container, &c, "pe", "ㄆㄧ");
  checkEq(&container, &c, "ped", "ㄆㄧˊ");
  checkEq(&container, &c, "pef", "ㄆㄧˇ");
  checkEq(&container, &c, "pej", "ㄆㄧˋ");
  checkEq(&container, &c, "pey", "ㄆㄧㄚ");
  checkEq(&container, &c, "pee", "ㄆㄧㄝ");
  checkEq(&container, &c, "peef", "ㄆㄧㄝˇ");
  checkEq(&container, &c, "peej", "ㄆㄧㄝˋ");
  checkEq(&container, &c, "pew", "ㄆㄧㄠ");
  checkEq(&container, &c, "pewd", "ㄆㄧㄠˊ");
  checkEq(&container, &c, "pewf", "ㄆㄧㄠˇ");
  checkEq(&container, &c, "pewj", "ㄆㄧㄠˋ");
  checkEq(&container, &c, "pem", "ㄆㄧㄢ");
  checkEq(&container, &c, "pemd", "ㄆㄧㄢˊ");
  checkEq(&container, &c, "pemf", "ㄆㄧㄢˇ");
  checkEq(&container, &c, "pemj", "ㄆㄧㄢˋ");
  checkEq(&container, &c, "pen", "ㄆㄧㄣ");
  checkEq(&container, &c, "pend", "ㄆㄧㄣˊ");
  checkEq(&container, &c, "penf", "ㄆㄧㄣˇ");
  checkEq(&container, &c, "penj", "ㄆㄧㄣˋ");
  checkEq(&container, &c, "pel", "ㄆㄧㄥ");
  checkEq(&container, &c, "peld", "ㄆㄧㄥˊ");
  checkEq(&container, &c, "pelf", "ㄆㄧㄥˇ");
  checkEq(&container, &c, "pelj", "ㄆㄧㄥˋ");
  checkEq(&container, &c, "px", "ㄆㄨ");
  checkEq(&container, &c, "pxd", "ㄆㄨˊ");
  checkEq(&container, &c, "pxf", "ㄆㄨˇ");
  checkEq(&container, &c, "pxj", "ㄆㄨˋ");
  checkEq(&container, &c, "my", "ㄇㄚ");
  checkEq(&container, &c, "myd", "ㄇㄚˊ");
  checkEq(&container, &c, "myf", "ㄇㄚˇ");
  checkEq(&container, &c, "myj", "ㄇㄚˋ");
  checkEq(&container, &c, "mys", "ㄇㄚ˙");
  checkEq(&container, &c, "mh", "ㄇㄛ");
  checkEq(&container, &c, "mhd", "ㄇㄛˊ");
  checkEq(&container, &c, "mhf", "ㄇㄛˇ");
  checkEq(&container, &c, "mhj", "ㄇㄛˋ");
  checkEq(&container, &c, "mhs", "ㄇㄛ˙");
  checkEq(&container, &c, "mg", "ㄇㄜ");
  checkEq(&container, &c, "mgj", "ㄇㄜˋ");
  checkEq(&container, &c, "mgs", "ㄇㄜ˙");
  checkEq(&container, &c, "mi", "ㄇㄞ");
  checkEq(&container, &c, "mid", "ㄇㄞˊ");
  checkEq(&container, &c, "mif", "ㄇㄞˇ");
  checkEq(&container, &c, "mij", "ㄇㄞˋ");
  checkEq(&container, &c, "mad", "ㄇㄟˊ");
  checkEq(&container, &c, "maf", "ㄇㄟˇ");
  checkEq(&container, &c, "maj", "ㄇㄟˋ");
  checkEq(&container, &c, "mw", "ㄇㄠ");
  checkEq(&container, &c, "mwd", "ㄇㄠˊ");
  checkEq(&container, &c, "mwf", "ㄇㄠˇ");
  checkEq(&container, &c, "mwj", "ㄇㄠˋ");
  checkEq(&container, &c, "mod", "ㄇㄡˊ");
  checkEq(&container, &c, "mof", "ㄇㄡˇ");
  checkEq(&container, &c, "moj", "ㄇㄡˋ");
  checkEq(&container, &c, "mm", "ㄇㄢ");
  checkEq(&container, &c, "mmd", "ㄇㄢˊ");
  checkEq(&container, &c, "mmf", "ㄇㄢˇ");
  checkEq(&container, &c, "mmj", "ㄇㄢˋ");
  checkEq(&container, &c, "mn", "ㄇㄣ");
  checkEq(&container, &c, "mnd", "ㄇㄣˊ");
  checkEq(&container, &c, "mnf", "ㄇㄣˇ");
  checkEq(&container, &c, "mnj", "ㄇㄣˋ");
  checkEq(&container, &c, "mns", "ㄇㄣ˙");
  checkEq(&container, &c, "mk", "ㄇㄤ");
  checkEq(&container, &c, "mkd", "ㄇㄤˊ");
  checkEq(&container, &c, "mkf", "ㄇㄤˇ");
  checkEq(&container, &c, "mkj", "ㄇㄤˋ");
  checkEq(&container, &c, "ml", "ㄇㄥ");
  checkEq(&container, &c, "mld", "ㄇㄥˊ");
  checkEq(&container, &c, "mlf", "ㄇㄥˇ");
  checkEq(&container, &c, "mlj", "ㄇㄥˋ");
  checkEq(&container, &c, "me", "ㄇㄧ");
  checkEq(&container, &c, "med", "ㄇㄧˊ");
  checkEq(&container, &c, "mef", "ㄇㄧˇ");
  checkEq(&container, &c, "mej", "ㄇㄧˋ");
  checkEq(&container, &c, "mee", "ㄇㄧㄝ");
  checkEq(&container, &c, "meed", "ㄇㄧㄝˊ");
  checkEq(&container, &c, "meej", "ㄇㄧㄝˋ");
  checkEq(&container, &c, "mew", "ㄇㄧㄠ");
  checkEq(&container, &c, "mewd", "ㄇㄧㄠˊ");
  checkEq(&container, &c, "mewf", "ㄇㄧㄠˇ");
  checkEq(&container, &c, "mewj", "ㄇㄧㄠˋ");
  checkEq(&container, &c, "meod", "ㄇㄧㄡˊ");
  checkEq(&container, &c, "meof", "ㄇㄧㄡˇ");
  checkEq(&container, &c, "meoj", "ㄇㄧㄡˋ");
  checkEq(&container, &c, "mem", "ㄇㄧㄢ");
  checkEq(&container, &c, "memd", "ㄇㄧㄢˊ");
  checkEq(&container, &c, "memf", "ㄇㄧㄢˇ");
  checkEq(&container, &c, "memj", "ㄇㄧㄢˋ");
  checkEq(&container, &c, "men", "ㄇㄧㄣ");
  checkEq(&container, &c, "mend", "ㄇㄧㄣˊ");
  checkEq(&container, &c, "menf", "ㄇㄧㄣˇ");
  checkEq(&container, &c, "meld", "ㄇㄧㄥˊ");
  checkEq(&container, &c, "melf", "ㄇㄧㄥˇ");
  checkEq(&container, &c, "melj", "ㄇㄧㄥˋ");
  checkEq(&container, &c, "mxd", "ㄇㄨˊ");
  checkEq(&container, &c, "mxf", "ㄇㄨˇ");
  checkEq(&container, &c, "mxj", "ㄇㄨˋ");
  checkEq(&container, &c, "fy", "ㄈㄚ");
  checkEq(&container, &c, "fyd", "ㄈㄚˊ");
  checkEq(&container, &c, "fyf", "ㄈㄚˇ");
  checkEq(&container, &c, "fyj", "ㄈㄚˋ");
  checkEq(&container, &c, "fhd", "ㄈㄛˊ");
  checkEq(&container, &c, "fa", "ㄈㄟ");
  checkEq(&container, &c, "fad", "ㄈㄟˊ");
  checkEq(&container, &c, "faf", "ㄈㄟˇ");
  checkEq(&container, &c, "faj", "ㄈㄟˋ");
  checkEq(&container, &c, "fo", "ㄈㄡ");
  checkEq(&container, &c, "fod", "ㄈㄡˊ");
  checkEq(&container, &c, "fof", "ㄈㄡˇ");
  checkEq(&container, &c, "foj", "ㄈㄡˋ");
  checkEq(&container, &c, "fm", "ㄈㄢ");
  checkEq(&container, &c, "fmd", "ㄈㄢˊ");
  checkEq(&container, &c, "fmf", "ㄈㄢˇ");
  checkEq(&container, &c, "fmj", "ㄈㄢˋ");
  checkEq(&container, &c, "fn", "ㄈㄣ");
  checkEq(&container, &c, "fnd", "ㄈㄣˊ");
  checkEq(&container, &c, "fnf", "ㄈㄣˇ");
  checkEq(&container, &c, "fnj", "ㄈㄣˋ");
  checkEq(&container, &c, "fns", "ㄈㄣ˙");
  checkEq(&container, &c, "fk", "ㄈㄤ");
  checkEq(&container, &c, "fkd", "ㄈㄤˊ");
  checkEq(&container, &c, "fkf", "ㄈㄤˇ");
  checkEq(&container, &c, "fkj", "ㄈㄤˋ");
  checkEq(&container, &c, "fl", "ㄈㄥ");
  checkEq(&container, &c, "fld", "ㄈㄥˊ");
  checkEq(&container, &c, "flf", "ㄈㄥˇ");
  checkEq(&container, &c, "flj", "ㄈㄥˋ");
  checkEq(&container, &c, "fewj", "ㄈㄧㄠˋ");
  checkEq(&container, &c, "fx", "ㄈㄨ");
  checkEq(&container, &c, "fxd", "ㄈㄨˊ");
  checkEq(&container, &c, "fxf", "ㄈㄨˇ");
  checkEq(&container, &c, "fxj", "ㄈㄨˋ");
  checkEq(&container, &c, "dy", "ㄉㄚ");
  checkEq(&container, &c, "dyd", "ㄉㄚˊ");
  checkEq(&container, &c, "dyf", "ㄉㄚˇ");
  checkEq(&container, &c, "dyj", "ㄉㄚˋ");
  checkEq(&container, &c, "dys", "ㄉㄚ˙");
  checkEq(&container, &c, "dg", "ㄉㄜ");
  checkEq(&container, &c, "dgd", "ㄉㄜˊ");
  checkEq(&container, &c, "dgs", "ㄉㄜ˙");
  checkEq(&container, &c, "di", "ㄉㄞ");
  checkEq(&container, &c, "dif", "ㄉㄞˇ");
  checkEq(&container, &c, "dij", "ㄉㄞˋ");
  checkEq(&container, &c, "daf", "ㄉㄟˇ");
  checkEq(&container, &c, "dw", "ㄉㄠ");
  checkEq(&container, &c, "dwd", "ㄉㄠˊ");
  checkEq(&container, &c, "dwf", "ㄉㄠˇ");
  checkEq(&container, &c, "dwj", "ㄉㄠˋ");
  checkEq(&container, &c, "do", "ㄉㄡ");
  checkEq(&container, &c, "dod", "ㄉㄡˊ");
  checkEq(&container, &c, "dof", "ㄉㄡˇ");
  checkEq(&container, &c, "doj", "ㄉㄡˋ");
  checkEq(&container, &c, "dm", "ㄉㄢ");
  checkEq(&container, &c, "dmf", "ㄉㄢˇ");
  checkEq(&container, &c, "dmj", "ㄉㄢˋ");
  checkEq(&container, &c, "dnj", "ㄉㄣˋ");
  checkEq(&container, &c, "dk", "ㄉㄤ");
  checkEq(&container, &c, "dkf", "ㄉㄤˇ");
  checkEq(&container, &c, "dkj", "ㄉㄤˋ");
  checkEq(&container, &c, "dl", "ㄉㄥ");
  checkEq(&container, &c, "dlf", "ㄉㄥˇ");
  checkEq(&container, &c, "dlj", "ㄉㄥˋ");
  checkEq(&container, &c, "de", "ㄉㄧ");
  checkEq(&container, &c, "ded", "ㄉㄧˊ");
  checkEq(&container, &c, "def", "ㄉㄧˇ");
  checkEq(&container, &c, "dej", "ㄉㄧˋ");
  checkEq(&container, &c, "deyf", "ㄉㄧㄚˇ");
  checkEq(&container, &c, "dee", "ㄉㄧㄝ");
  checkEq(&container, &c, "deed", "ㄉㄧㄝˊ");
  checkEq(&container, &c, "deef", "ㄉㄧㄝˇ");
  checkEq(&container, &c, "deej", "ㄉㄧㄝˋ");
  checkEq(&container, &c, "dew", "ㄉㄧㄠ");
  checkEq(&container, &c, "dewf", "ㄉㄧㄠˇ");
  checkEq(&container, &c, "dewj", "ㄉㄧㄠˋ");
  checkEq(&container, &c, "deo", "ㄉㄧㄡ");
  checkEq(&container, &c, "dem", "ㄉㄧㄢ");
  checkEq(&container, &c, "demd", "ㄉㄧㄢˊ");
  checkEq(&container, &c, "demf", "ㄉㄧㄢˇ");
  checkEq(&container, &c, "demj", "ㄉㄧㄢˋ");
  checkEq(&container, &c, "del", "ㄉㄧㄥ");
  checkEq(&container, &c, "deld", "ㄉㄧㄥˊ");
  checkEq(&container, &c, "delf", "ㄉㄧㄥˇ");
  checkEq(&container, &c, "delj", "ㄉㄧㄥˋ");
  checkEq(&container, &c, "dx", "ㄉㄨ");
  checkEq(&container, &c, "dxd", "ㄉㄨˊ");
  checkEq(&container, &c, "dxf", "ㄉㄨˇ");
  checkEq(&container, &c, "dxj", "ㄉㄨˋ");
  checkEq(&container, &c, "dxh", "ㄉㄨㄛ");
  checkEq(&container, &c, "dxhd", "ㄉㄨㄛˊ");
  checkEq(&container, &c, "dxhf", "ㄉㄨㄛˇ");
  checkEq(&container, &c, "dxhj", "ㄉㄨㄛˋ");
  checkEq(&container, &c, "dxhs", "ㄉㄨㄛ˙");
  checkEq(&container, &c, "dxa", "ㄉㄨㄟ");
  checkEq(&container, &c, "dxaf", "ㄉㄨㄟˇ");
  checkEq(&container, &c, "dxaj", "ㄉㄨㄟˋ");
  checkEq(&container, &c, "dxm", "ㄉㄨㄢ");
  checkEq(&container, &c, "dxmf", "ㄉㄨㄢˇ");
  checkEq(&container, &c, "dxmj", "ㄉㄨㄢˋ");
  checkEq(&container, &c, "dxn", "ㄉㄨㄣ");
  checkEq(&container, &c, "dxnf", "ㄉㄨㄣˇ");
  checkEq(&container, &c, "dxnj", "ㄉㄨㄣˋ");
  checkEq(&container, &c, "dxl", "ㄉㄨㄥ");
  checkEq(&container, &c, "dxlf", "ㄉㄨㄥˇ");
  checkEq(&container, &c, "dxlj", "ㄉㄨㄥˋ");
  checkEq(&container, &c, "ty", "ㄊㄚ");
  checkEq(&container, &c, "tyf", "ㄊㄚˇ");
  checkEq(&container, &c, "tyj", "ㄊㄚˋ");
  checkEq(&container, &c, "tgj", "ㄊㄜˋ");
  checkEq(&container, &c, "ti", "ㄊㄞ");
  checkEq(&container, &c, "tid", "ㄊㄞˊ");
  checkEq(&container, &c, "tif", "ㄊㄞˇ");
  checkEq(&container, &c, "tij", "ㄊㄞˋ");
  checkEq(&container, &c, "tis", "ㄊㄞ˙");
  checkEq(&container, &c, "tw", "ㄊㄠ");
  checkEq(&container, &c, "twd", "ㄊㄠˊ");
  checkEq(&container, &c, "twf", "ㄊㄠˇ");
  checkEq(&container, &c, "twj", "ㄊㄠˋ");
  checkEq(&container, &c, "tws", "ㄊㄠ˙");
  checkEq(&container, &c, "to", "ㄊㄡ");
  checkEq(&container, &c, "tod", "ㄊㄡˊ");
  checkEq(&container, &c, "tof", "ㄊㄡˇ");
  checkEq(&container, &c, "toj", "ㄊㄡˋ");
  checkEq(&container, &c, "tos", "ㄊㄡ˙");
  checkEq(&container, &c, "tm", "ㄊㄢ");
  checkEq(&container, &c, "tmd", "ㄊㄢˊ");
  checkEq(&container, &c, "tmf", "ㄊㄢˇ");
  checkEq(&container, &c, "tmj", "ㄊㄢˋ");
  checkEq(&container, &c, "tk", "ㄊㄤ");
  checkEq(&container, &c, "tkd", "ㄊㄤˊ");
  checkEq(&container, &c, "tkf", "ㄊㄤˇ");
  checkEq(&container, &c, "tkj", "ㄊㄤˋ");
  checkEq(&container, &c, "tl", "ㄊㄥ");
  checkEq(&container, &c, "tld", "ㄊㄥˊ");
  checkEq(&container, &c, "tlj", "ㄊㄥˋ");
  checkEq(&container, &c, "te", "ㄊㄧ");
  checkEq(&container, &c, "ted", "ㄊㄧˊ");
  checkEq(&container, &c, "tef", "ㄊㄧˇ");
  checkEq(&container, &c, "tej", "ㄊㄧˋ");
  checkEq(&container, &c, "tee", "ㄊㄧㄝ");
  checkEq(&container, &c, "teed", "ㄊㄧㄝˊ");
  checkEq(&container, &c, "teef", "ㄊㄧㄝˇ");
  checkEq(&container, &c, "teej", "ㄊㄧㄝˋ");
  checkEq(&container, &c, "tew", "ㄊㄧㄠ");
  checkEq(&container, &c, "tewd", "ㄊㄧㄠˊ");
  checkEq(&container, &c, "tewf", "ㄊㄧㄠˇ");
  checkEq(&container, &c, "tewj", "ㄊㄧㄠˋ");
  checkEq(&container, &c, "tem", "ㄊㄧㄢ");
  checkEq(&container, &c, "temd", "ㄊㄧㄢˊ");
  checkEq(&container, &c, "temf", "ㄊㄧㄢˇ");
  checkEq(&container, &c, "temj", "ㄊㄧㄢˋ");
  checkEq(&container, &c, "tel", "ㄊㄧㄥ");
  checkEq(&container, &c, "teld", "ㄊㄧㄥˊ");
  checkEq(&container, &c, "telf", "ㄊㄧㄥˇ");
  checkEq(&container, &c, "telj", "ㄊㄧㄥˋ");
  checkEq(&container, &c, "tx", "ㄊㄨ");
  checkEq(&container, &c, "txd", "ㄊㄨˊ");
  checkEq(&container, &c, "txf", "ㄊㄨˇ");
  checkEq(&container, &c, "txj", "ㄊㄨˋ");
  checkEq(&container, &c, "txh", "ㄊㄨㄛ");
  checkEq(&container, &c, "txhd", "ㄊㄨㄛˊ");
  checkEq(&container, &c, "txhf", "ㄊㄨㄛˇ");
  checkEq(&container, &c, "txhj", "ㄊㄨㄛˋ");
  checkEq(&container, &c, "txa", "ㄊㄨㄟ");
  checkEq(&container, &c, "txad", "ㄊㄨㄟˊ");
  checkEq(&container, &c, "txaf", "ㄊㄨㄟˇ");
  checkEq(&container, &c, "txaj", "ㄊㄨㄟˋ");
  checkEq(&container, &c, "txm", "ㄊㄨㄢ");
  checkEq(&container, &c, "txmd", "ㄊㄨㄢˊ");
  checkEq(&container, &c, "txmf", "ㄊㄨㄢˇ");
  checkEq(&container, &c, "txmj", "ㄊㄨㄢˋ");
  checkEq(&container, &c, "txn", "ㄊㄨㄣ");
  checkEq(&container, &c, "txnd", "ㄊㄨㄣˊ");
  checkEq(&container, &c, "txnf", "ㄊㄨㄣˇ");
  checkEq(&container, &c, "txnj", "ㄊㄨㄣˋ");
  checkEq(&container, &c, "txl", "ㄊㄨㄥ");
  checkEq(&container, &c, "txld", "ㄊㄨㄥˊ");
  checkEq(&container, &c, "txlf", "ㄊㄨㄥˇ");
  checkEq(&container, &c, "txlj", "ㄊㄨㄥˋ");
  checkEq(&container, &c, "ny", "ㄋㄚ");
  checkEq(&container, &c, "nyd", "ㄋㄚˊ");
  checkEq(&container, &c, "nyf", "ㄋㄚˇ");
  checkEq(&container, &c, "nyj", "ㄋㄚˋ");
  checkEq(&container, &c, "nys", "ㄋㄚ˙");
  checkEq(&container, &c, "ngj", "ㄋㄜˋ");
  checkEq(&container, &c, "ngs", "ㄋㄜ˙");
  checkEq(&container, &c, "nid", "ㄋㄞˊ");
  checkEq(&container, &c, "nif", "ㄋㄞˇ");
  checkEq(&container, &c, "nij", "ㄋㄞˋ");
  checkEq(&container, &c, "nad", "ㄋㄟˊ");
  checkEq(&container, &c, "naf", "ㄋㄟˇ");
  checkEq(&container, &c, "naj", "ㄋㄟˋ");
  checkEq(&container, &c, "nw", "ㄋㄠ");
  checkEq(&container, &c, "nwd", "ㄋㄠˊ");
  checkEq(&container, &c, "nwf", "ㄋㄠˇ");
  checkEq(&container, &c, "nwj", "ㄋㄠˋ");
  checkEq(&container, &c, "nod", "ㄋㄡˊ");
  checkEq(&container, &c, "nof", "ㄋㄡˇ");
  checkEq(&container, &c, "noj", "ㄋㄡˋ");
  checkEq(&container, &c, "nm", "ㄋㄢ");
  checkEq(&container, &c, "nmd", "ㄋㄢˊ");
  checkEq(&container, &c, "nmf", "ㄋㄢˇ");
  checkEq(&container, &c, "nmj", "ㄋㄢˋ");
  checkEq(&container, &c, "nnf", "ㄋㄣˇ");
  checkEq(&container, &c, "nnj", "ㄋㄣˋ");
  checkEq(&container, &c, "nk", "ㄋㄤ");
  checkEq(&container, &c, "nkd", "ㄋㄤˊ");
  checkEq(&container, &c, "nkf", "ㄋㄤˇ");
  checkEq(&container, &c, "nkj", "ㄋㄤˋ");
  checkEq(&container, &c, "nks", "ㄋㄤ˙");
  checkEq(&container, &c, "nld", "ㄋㄥˊ");
  checkEq(&container, &c, "nlf", "ㄋㄥˇ");
  checkEq(&container, &c, "ne", "ㄋㄧ");
  checkEq(&container, &c, "ned", "ㄋㄧˊ");
  checkEq(&container, &c, "nef", "ㄋㄧˇ");
  checkEq(&container, &c, "nej", "ㄋㄧˋ");
  checkEq(&container, &c, "nee", "ㄋㄧㄝ");
  checkEq(&container, &c, "need", "ㄋㄧㄝˊ");
  checkEq(&container, &c, "neej", "ㄋㄧㄝˋ");
  checkEq(&container, &c, "newf", "ㄋㄧㄠˇ");
  checkEq(&container, &c, "newj", "ㄋㄧㄠˋ");
  checkEq(&container, &c, "neo", "ㄋㄧㄡ");
  checkEq(&container, &c, "neod", "ㄋㄧㄡˊ");
  checkEq(&container, &c, "neof", "ㄋㄧㄡˇ");
  checkEq(&container, &c, "neoj", "ㄋㄧㄡˋ");
  checkEq(&container, &c, "nem", "ㄋㄧㄢ");
  checkEq(&container, &c, "nemd", "ㄋㄧㄢˊ");
  checkEq(&container, &c, "nemf", "ㄋㄧㄢˇ");
  checkEq(&container, &c, "nemj", "ㄋㄧㄢˋ");
  checkEq(&container, &c, "nen", "ㄋㄧㄣ");
  checkEq(&container, &c, "nend", "ㄋㄧㄣˊ");
  checkEq(&container, &c, "nenf", "ㄋㄧㄣˇ");
  checkEq(&container, &c, "nenj", "ㄋㄧㄣˋ");
  checkEq(&container, &c, "nekd", "ㄋㄧㄤˊ");
  checkEq(&container, &c, "nekf", "ㄋㄧㄤˇ");
  checkEq(&container, &c, "nekj", "ㄋㄧㄤˋ");
  checkEq(&container, &c, "neld", "ㄋㄧㄥˊ");
  checkEq(&container, &c, "nelf", "ㄋㄧㄥˇ");
  checkEq(&container, &c, "nelj", "ㄋㄧㄥˋ");
  checkEq(&container, &c, "nxd", "ㄋㄨˊ");
  checkEq(&container, &c, "nxf", "ㄋㄨˇ");
  checkEq(&container, &c, "nxj", "ㄋㄨˋ");
  checkEq(&container, &c, "nxhd", "ㄋㄨㄛˊ");
  checkEq(&container, &c, "nxhf", "ㄋㄨㄛˇ");
  checkEq(&container, &c, "nxhj", "ㄋㄨㄛˋ");
  checkEq(&container, &c, "nxad", "ㄋㄨㄟˊ");
  checkEq(&container, &c, "nxmd", "ㄋㄨㄢˊ");
  checkEq(&container, &c, "nxmf", "ㄋㄨㄢˇ");
  checkEq(&container, &c, "nxmj", "ㄋㄨㄢˋ");
  checkEq(&container, &c, "nxnd", "ㄋㄨㄣˊ");
  checkEq(&container, &c, "nxld", "ㄋㄨㄥˊ");
  checkEq(&container, &c, "nxlf", "ㄋㄨㄥˇ");
  checkEq(&container, &c, "nxlj", "ㄋㄨㄥˋ");
  checkEq(&container, &c, "nud", "ㄋㄩˊ");
  checkEq(&container, &c, "nuf", "ㄋㄩˇ");
  checkEq(&container, &c, "nuj", "ㄋㄩˋ");
  checkEq(&container, &c, "nuej", "ㄋㄩㄝˋ");
  checkEq(&container, &c, "ly", "ㄌㄚ");
  checkEq(&container, &c, "lyd", "ㄌㄚˊ");
  checkEq(&container, &c, "lyf", "ㄌㄚˇ");
  checkEq(&container, &c, "lyj", "ㄌㄚˋ");
  checkEq(&container, &c, "lys", "ㄌㄚ˙");
  checkEq(&container, &c, "lh", "ㄌㄛ");
  checkEq(&container, &c, "lhs", "ㄌㄛ˙");
  checkEq(&container, &c, "lg", "ㄌㄜ");
  checkEq(&container, &c, "lgd", "ㄌㄜˊ");
  checkEq(&container, &c, "lgj", "ㄌㄜˋ");
  checkEq(&container, &c, "lgs", "ㄌㄜ˙");
  checkEq(&container, &c, "lid", "ㄌㄞˊ");
  checkEq(&container, &c, "lif", "ㄌㄞˇ");
  checkEq(&container, &c, "lij", "ㄌㄞˋ");
  checkEq(&container, &c, "la", "ㄌㄟ");
  checkEq(&container, &c, "lad", "ㄌㄟˊ");
  checkEq(&container, &c, "laf", "ㄌㄟˇ");
  checkEq(&container, &c, "laj", "ㄌㄟˋ");
  checkEq(&container, &c, "las", "ㄌㄟ˙");
  checkEq(&container, &c, "lw", "ㄌㄠ");
  checkEq(&container, &c, "lwd", "ㄌㄠˊ");
  checkEq(&container, &c, "lwf", "ㄌㄠˇ");
  checkEq(&container, &c, "lwj", "ㄌㄠˋ");
  checkEq(&container, &c, "lo", "ㄌㄡ");
  checkEq(&container, &c, "lod", "ㄌㄡˊ");
  checkEq(&container, &c, "lof", "ㄌㄡˇ");
  checkEq(&container, &c, "loj", "ㄌㄡˋ");
  checkEq(&container, &c, "los", "ㄌㄡ˙");
  checkEq(&container, &c, "lmd", "ㄌㄢˊ");
  checkEq(&container, &c, "lmf", "ㄌㄢˇ");
  checkEq(&container, &c, "lmj", "ㄌㄢˋ");
  checkEq(&container, &c, "lk", "ㄌㄤ");
  checkEq(&container, &c, "lkd", "ㄌㄤˊ");
  checkEq(&container, &c, "lkf", "ㄌㄤˇ");
  checkEq(&container, &c, "lkj", "ㄌㄤˋ");
  checkEq(&container, &c, "ll", "ㄌㄥ");
  checkEq(&container, &c, "lld", "ㄌㄥˊ");
  checkEq(&container, &c, "llf", "ㄌㄥˇ");
  checkEq(&container, &c, "llj", "ㄌㄥˋ");
  checkEq(&container, &c, "le", "ㄌㄧ");
  checkEq(&container, &c, "led", "ㄌㄧˊ");
  checkEq(&container, &c, "lef", "ㄌㄧˇ");
  checkEq(&container, &c, "lej", "ㄌㄧˋ");
  checkEq(&container, &c, "les", "ㄌㄧ˙");
  checkEq(&container, &c, "leyf", "ㄌㄧㄚˇ");
  checkEq(&container, &c, "lee", "ㄌㄧㄝ");
  checkEq(&container, &c, "leed", "ㄌㄧㄝˊ");
  checkEq(&container, &c, "leef", "ㄌㄧㄝˇ");
  checkEq(&container, &c, "leej", "ㄌㄧㄝˋ");
  checkEq(&container, &c, "lew", "ㄌㄧㄠ");
  checkEq(&container, &c, "lewd", "ㄌㄧㄠˊ");
  checkEq(&container, &c, "lewf", "ㄌㄧㄠˇ");
  checkEq(&container, &c, "lewj", "ㄌㄧㄠˋ");
  checkEq(&container, &c, "leo", "ㄌㄧㄡ");
  checkEq(&container, &c, "leod", "ㄌㄧㄡˊ");
  checkEq(&container, &c, "leof", "ㄌㄧㄡˇ");
  checkEq(&container, &c, "leoj", "ㄌㄧㄡˋ");
  checkEq(&container, &c, "lem", "ㄌㄧㄢ");
  checkEq(&container, &c, "lemd", "ㄌㄧㄢˊ");
  checkEq(&container, &c, "lemf", "ㄌㄧㄢˇ");
  checkEq(&container, &c, "lemj", "ㄌㄧㄢˋ");
  checkEq(&container, &c, "lend", "ㄌㄧㄣˊ");
  checkEq(&container, &c, "lenf", "ㄌㄧㄣˇ");
  checkEq(&container, &c, "lenj", "ㄌㄧㄣˋ");
  checkEq(&container, &c, "lekd", "ㄌㄧㄤˊ");
  checkEq(&container, &c, "lekf", "ㄌㄧㄤˇ");
  checkEq(&container, &c, "lekj", "ㄌㄧㄤˋ");
  checkEq(&container, &c, "lel", "ㄌㄧㄥ");
  checkEq(&container, &c, "leld", "ㄌㄧㄥˊ");
  checkEq(&container, &c, "lelf", "ㄌㄧㄥˇ");
  checkEq(&container, &c, "lelj", "ㄌㄧㄥˋ");
  checkEq(&container, &c, "lx", "ㄌㄨ");
  checkEq(&container, &c, "lxd", "ㄌㄨˊ");
  checkEq(&container, &c, "lxf", "ㄌㄨˇ");
  checkEq(&container, &c, "lxj", "ㄌㄨˋ");
  checkEq(&container, &c, "lxh", "ㄌㄨㄛ");
  checkEq(&container, &c, "lxhd", "ㄌㄨㄛˊ");
  checkEq(&container, &c, "lxhf", "ㄌㄨㄛˇ");
  checkEq(&container, &c, "lxhj", "ㄌㄨㄛˋ");
  checkEq(&container, &c, "lxhs", "ㄌㄨㄛ˙");
  checkEq(&container, &c, "lxmd", "ㄌㄨㄢˊ");
  checkEq(&container, &c, "lxmf", "ㄌㄨㄢˇ");
  checkEq(&container, &c, "lxmj", "ㄌㄨㄢˋ");
  checkEq(&container, &c, "lxn", "ㄌㄨㄣ");
  checkEq(&container, &c, "lxnd", "ㄌㄨㄣˊ");
  checkEq(&container, &c, "lxnf", "ㄌㄨㄣˇ");
  checkEq(&container, &c, "lxnj", "ㄌㄨㄣˋ");
  checkEq(&container, &c, "lxl", "ㄌㄨㄥ");
  checkEq(&container, &c, "lxld", "ㄌㄨㄥˊ");
  checkEq(&container, &c, "lxlf", "ㄌㄨㄥˇ");
  checkEq(&container, &c, "lxlj", "ㄌㄨㄥˋ");
  checkEq(&container, &c, "lu", "ㄌㄩ");
  checkEq(&container, &c, "lud", "ㄌㄩˊ");
  checkEq(&container, &c, "luf", "ㄌㄩˇ");
  checkEq(&container, &c, "luj", "ㄌㄩˋ");
  checkEq(&container, &c, "lue", "ㄌㄩㄝ");
  checkEq(&container, &c, "luef", "ㄌㄩㄝˇ");
  checkEq(&container, &c, "luej", "ㄌㄩㄝˋ");
  checkEq(&container, &c, "lumd", "ㄌㄩㄢˊ");
  checkEq(&container, &c, "lumf", "ㄌㄩㄢˇ");
  checkEq(&container, &c, "gy", "ㄍㄚ");
  checkEq(&container, &c, "gyd", "ㄍㄚˊ");
  checkEq(&container, &c, "gyf", "ㄍㄚˇ");
  checkEq(&container, &c, "gyj", "ㄍㄚˋ");
  checkEq(&container, &c, "gys", "ㄍㄚ˙");
  checkEq(&container, &c, "gg", "ㄍㄜ");
  checkEq(&container, &c, "ggd", "ㄍㄜˊ");
  checkEq(&container, &c, "ggf", "ㄍㄜˇ");
  checkEq(&container, &c, "ggj", "ㄍㄜˋ");
  checkEq(&container, &c, "ggs", "ㄍㄜ˙");
  checkEq(&container, &c, "gi", "ㄍㄞ");
  checkEq(&container, &c, "gif", "ㄍㄞˇ");
  checkEq(&container, &c, "gij", "ㄍㄞˋ");
  checkEq(&container, &c, "gaf", "ㄍㄟˇ");
  checkEq(&container, &c, "gw", "ㄍㄠ");
  checkEq(&container, &c, "gwf", "ㄍㄠˇ");
  checkEq(&container, &c, "gwj", "ㄍㄠˋ");
  checkEq(&container, &c, "go", "ㄍㄡ");
  checkEq(&container, &c, "gof", "ㄍㄡˇ");
  checkEq(&container, &c, "goj", "ㄍㄡˋ");
  checkEq(&container, &c, "gm", "ㄍㄢ");
  checkEq(&container, &c, "gmf", "ㄍㄢˇ");
  checkEq(&container, &c, "gmj", "ㄍㄢˋ");
  checkEq(&container, &c, "gn", "ㄍㄣ");
  checkEq(&container, &c, "gnd", "ㄍㄣˊ");
  checkEq(&container, &c, "gnf", "ㄍㄣˇ");
  checkEq(&container, &c, "gnj", "ㄍㄣˋ");
  checkEq(&container, &c, "gk", "ㄍㄤ");
  checkEq(&container, &c, "gkf", "ㄍㄤˇ");
  checkEq(&container, &c, "gkj", "ㄍㄤˋ");
  checkEq(&container, &c, "gl", "ㄍㄥ");
  checkEq(&container, &c, "glf", "ㄍㄥˇ");
  checkEq(&container, &c, "glj", "ㄍㄥˋ");
  checkEq(&container, &c, "gx", "ㄍㄨ");
  checkEq(&container, &c, "gxd", "ㄍㄨˊ");
  checkEq(&container, &c, "gxf", "ㄍㄨˇ");
  checkEq(&container, &c, "gxj", "ㄍㄨˋ");
  checkEq(&container, &c, "gxy", "ㄍㄨㄚ");
  checkEq(&container, &c, "gxyd", "ㄍㄨㄚˊ");
  checkEq(&container, &c, "gxyf", "ㄍㄨㄚˇ");
  checkEq(&container, &c, "gxyj", "ㄍㄨㄚˋ");
  checkEq(&container, &c, "gxh", "ㄍㄨㄛ");
  checkEq(&container, &c, "gxhd", "ㄍㄨㄛˊ");
  checkEq(&container, &c, "gxhf", "ㄍㄨㄛˇ");
  checkEq(&container, &c, "gxhj", "ㄍㄨㄛˋ");
  checkEq(&container, &c, "gxi", "ㄍㄨㄞ");
  checkEq(&container, &c, "gxif", "ㄍㄨㄞˇ");
  checkEq(&container, &c, "gxij", "ㄍㄨㄞˋ");
  checkEq(&container, &c, "gxa", "ㄍㄨㄟ");
  checkEq(&container, &c, "gxaf", "ㄍㄨㄟˇ");
  checkEq(&container, &c, "gxaj", "ㄍㄨㄟˋ");
  checkEq(&container, &c, "gxm", "ㄍㄨㄢ");
  checkEq(&container, &c, "gxmf", "ㄍㄨㄢˇ");
  checkEq(&container, &c, "gxmj", "ㄍㄨㄢˋ");
  checkEq(&container, &c, "gxn", "ㄍㄨㄣ");
  checkEq(&container, &c, "gxnf", "ㄍㄨㄣˇ");
  checkEq(&container, &c, "gxnj", "ㄍㄨㄣˋ");
  checkEq(&container, &c, "gxk", "ㄍㄨㄤ");
  checkEq(&container, &c, "gxkf", "ㄍㄨㄤˇ");
  checkEq(&container, &c, "gxkj", "ㄍㄨㄤˋ");
  checkEq(&container, &c, "gxl", "ㄍㄨㄥ");
  checkEq(&container, &c, "gxld", "ㄍㄨㄥˊ");
  checkEq(&container, &c, "gxlf", "ㄍㄨㄥˇ");
  checkEq(&container, &c, "gxlj", "ㄍㄨㄥˋ");
  checkEq(&container, &c, "ky", "ㄎㄚ");
  checkEq(&container, &c, "kyf", "ㄎㄚˇ");
  checkEq(&container, &c, "kyj", "ㄎㄚˋ");
  checkEq(&container, &c, "kg", "ㄎㄜ");
  checkEq(&container, &c, "kgd", "ㄎㄜˊ");
  checkEq(&container, &c, "kgf", "ㄎㄜˇ");
  checkEq(&container, &c, "kgj", "ㄎㄜˋ");
  checkEq(&container, &c, "ki", "ㄎㄞ");
  checkEq(&container, &c, "kif", "ㄎㄞˇ");
  checkEq(&container, &c, "kij", "ㄎㄞˋ");
  checkEq(&container, &c, "kw", "ㄎㄠ");
  checkEq(&container, &c, "kwf", "ㄎㄠˇ");
  checkEq(&container, &c, "kwj", "ㄎㄠˋ");
  checkEq(&container, &c, "ko", "ㄎㄡ");
  checkEq(&container, &c, "kof", "ㄎㄡˇ");
  checkEq(&container, &c, "koj", "ㄎㄡˋ");
  checkEq(&container, &c, "km", "ㄎㄢ");
  checkEq(&container, &c, "kmf", "ㄎㄢˇ");
  checkEq(&container, &c, "kmj", "ㄎㄢˋ");
  checkEq(&container, &c, "kn", "ㄎㄣ");
  checkEq(&container, &c, "knf", "ㄎㄣˇ");
  checkEq(&container, &c, "knj", "ㄎㄣˋ");
  checkEq(&container, &c, "kk", "ㄎㄤ");
  checkEq(&container, &c, "kkd", "ㄎㄤˊ");
  checkEq(&container, &c, "kkf", "ㄎㄤˇ");
  checkEq(&container, &c, "kkj", "ㄎㄤˋ");
  checkEq(&container, &c, "kl", "ㄎㄥ");
  checkEq(&container, &c, "klf", "ㄎㄥˇ");
  checkEq(&container, &c, "kx", "ㄎㄨ");
  checkEq(&container, &c, "kxd", "ㄎㄨˊ");
  checkEq(&container, &c, "kxf", "ㄎㄨˇ");
  checkEq(&container, &c, "kxj", "ㄎㄨˋ");
  checkEq(&container, &c, "kxy", "ㄎㄨㄚ");
  checkEq(&container, &c, "kxyf", "ㄎㄨㄚˇ");
  checkEq(&container, &c, "kxyj", "ㄎㄨㄚˋ");
  checkEq(&container, &c, "kxhj", "ㄎㄨㄛˋ");
  checkEq(&container, &c, "kxi", "ㄎㄨㄞ");
  checkEq(&container, &c, "kxif", "ㄎㄨㄞˇ");
  checkEq(&container, &c, "kxij", "ㄎㄨㄞˋ");
  checkEq(&container, &c, "kxa", "ㄎㄨㄟ");
  checkEq(&container, &c, "kxad", "ㄎㄨㄟˊ");
  checkEq(&container, &c, "kxaf", "ㄎㄨㄟˇ");
  checkEq(&container, &c, "kxaj", "ㄎㄨㄟˋ");
  checkEq(&container, &c, "kxm", "ㄎㄨㄢ");
  checkEq(&container, &c, "kxmf", "ㄎㄨㄢˇ");
  checkEq(&container, &c, "kxmj", "ㄎㄨㄢˋ");
  checkEq(&container, &c, "kxn", "ㄎㄨㄣ");
  checkEq(&container, &c, "kxnf", "ㄎㄨㄣˇ");
  checkEq(&container, &c, "kxnj", "ㄎㄨㄣˋ");
  checkEq(&container, &c, "kxk", "ㄎㄨㄤ");
  checkEq(&container, &c, "kxkd", "ㄎㄨㄤˊ");
  checkEq(&container, &c, "kxkf", "ㄎㄨㄤˇ");
  checkEq(&container, &c, "kxkj", "ㄎㄨㄤˋ");
  checkEq(&container, &c, "kxl", "ㄎㄨㄥ");
  checkEq(&container, &c, "kxlf", "ㄎㄨㄥˇ");
  checkEq(&container, &c, "kxlj", "ㄎㄨㄥˋ");
  checkEq(&container, &c, "hy", "ㄏㄚ");
  checkEq(&container, &c, "hyd", "ㄏㄚˊ");
  checkEq(&container, &c, "hyf", "ㄏㄚˇ");
  checkEq(&container, &c, "hg", "ㄏㄜ");
  checkEq(&container, &c, "hgd", "ㄏㄜˊ");
  checkEq(&container, &c, "hgf", "ㄏㄜˇ");
  checkEq(&container, &c, "hgj", "ㄏㄜˋ");
  checkEq(&container, &c, "hi", "ㄏㄞ");
  checkEq(&container, &c, "hid", "ㄏㄞˊ");
  checkEq(&container, &c, "hif", "ㄏㄞˇ");
  checkEq(&container, &c, "hij", "ㄏㄞˋ");
  checkEq(&container, &c, "ha", "ㄏㄟ");
  checkEq(&container, &c, "haf", "ㄏㄟˇ");
  checkEq(&container, &c, "hw", "ㄏㄠ");
  checkEq(&container, &c, "hwd", "ㄏㄠˊ");
  checkEq(&container, &c, "hwf", "ㄏㄠˇ");
  checkEq(&container, &c, "hwj", "ㄏㄠˋ");
  checkEq(&container, &c, "ho", "ㄏㄡ");
  checkEq(&container, &c, "hod", "ㄏㄡˊ");
  checkEq(&container, &c, "hof", "ㄏㄡˇ");
  checkEq(&container, &c, "hoj", "ㄏㄡˋ");
  checkEq(&container, &c, "hm", "ㄏㄢ");
  checkEq(&container, &c, "hmd", "ㄏㄢˊ");
  checkEq(&container, &c, "hmf", "ㄏㄢˇ");
  checkEq(&container, &c, "hmj", "ㄏㄢˋ");
  checkEq(&container, &c, "hn", "ㄏㄣ");
  checkEq(&container, &c, "hnd", "ㄏㄣˊ");
  checkEq(&container, &c, "hnf", "ㄏㄣˇ");
  checkEq(&container, &c, "hnj", "ㄏㄣˋ");
  checkEq(&container, &c, "hk", "ㄏㄤ");
  checkEq(&container, &c, "hkd", "ㄏㄤˊ");
  checkEq(&container, &c, "hkf", "ㄏㄤˇ");
  checkEq(&container, &c, "hkj", "ㄏㄤˋ");
  checkEq(&container, &c, "hl", "ㄏㄥ");
  checkEq(&container, &c, "hld", "ㄏㄥˊ");
  checkEq(&container, &c, "hlj", "ㄏㄥˋ");
  checkEq(&container, &c, "hx", "ㄏㄨ");
  checkEq(&container, &c, "hxd", "ㄏㄨˊ");
  checkEq(&container, &c, "hxf", "ㄏㄨˇ");
  checkEq(&container, &c, "hxj", "ㄏㄨˋ");
  checkEq(&container, &c, "hxy", "ㄏㄨㄚ");
  checkEq(&container, &c, "hxyd", "ㄏㄨㄚˊ");
  checkEq(&container, &c, "hxyf", "ㄏㄨㄚˇ");
  checkEq(&container, &c, "hxyj", "ㄏㄨㄚˋ");
  checkEq(&container, &c, "hxh", "ㄏㄨㄛ");
  checkEq(&container, &c, "hxhd", "ㄏㄨㄛˊ");
  checkEq(&container, &c, "hxhf", "ㄏㄨㄛˇ");
  checkEq(&container, &c, "hxhj", "ㄏㄨㄛˋ");
  checkEq(&container, &c, "hxhs", "ㄏㄨㄛ˙");
  checkEq(&container, &c, "hxid", "ㄏㄨㄞˊ");
  checkEq(&container, &c, "hxij", "ㄏㄨㄞˋ");
  checkEq(&container, &c, "hxa", "ㄏㄨㄟ");
  checkEq(&container, &c, "hxad", "ㄏㄨㄟˊ");
  checkEq(&container, &c, "hxaf", "ㄏㄨㄟˇ");
  checkEq(&container, &c, "hxaj", "ㄏㄨㄟˋ");
  checkEq(&container, &c, "hxm", "ㄏㄨㄢ");
  checkEq(&container, &c, "hxmd", "ㄏㄨㄢˊ");
  checkEq(&container, &c, "hxmf", "ㄏㄨㄢˇ");
  checkEq(&container, &c, "hxmj", "ㄏㄨㄢˋ");
  checkEq(&container, &c, "hxn", "ㄏㄨㄣ");
  checkEq(&container, &c, "hxnd", "ㄏㄨㄣˊ");
  checkEq(&container, &c, "hxnf", "ㄏㄨㄣˇ");
  checkEq(&container, &c, "hxnj", "ㄏㄨㄣˋ");
  checkEq(&container, &c, "hxk", "ㄏㄨㄤ");
  checkEq(&container, &c, "hxkd", "ㄏㄨㄤˊ");
  checkEq(&container, &c, "hxkf", "ㄏㄨㄤˇ");
  checkEq(&container, &c, "hxkj", "ㄏㄨㄤˋ");
  checkEq(&container, &c, "hxks", "ㄏㄨㄤ˙");
  checkEq(&container, &c, "hxl", "ㄏㄨㄥ");
  checkEq(&container, &c, "hxld", "ㄏㄨㄥˊ");
  checkEq(&container, &c, "hxlf", "ㄏㄨㄥˇ");
  checkEq(&container, &c, "hxlj", "ㄏㄨㄥˋ");
  checkEq(&container, &c, "je", "ㄐㄧ");
  checkEq(&container, &c, "jed", "ㄐㄧˊ");
  checkEq(&container, &c, "jef", "ㄐㄧˇ");
  checkEq(&container, &c, "jej", "ㄐㄧˋ");
  checkEq(&container, &c, "jey", "ㄐㄧㄚ");
  checkEq(&container, &c, "jeyd", "ㄐㄧㄚˊ");
  checkEq(&container, &c, "jeyf", "ㄐㄧㄚˇ");
  checkEq(&container, &c, "jeyj", "ㄐㄧㄚˋ");
  checkEq(&container, &c, "jee", "ㄐㄧㄝ");
  checkEq(&container, &c, "jeed", "ㄐㄧㄝˊ");
  checkEq(&container, &c, "jeef", "ㄐㄧㄝˇ");
  checkEq(&container, &c, "jeej", "ㄐㄧㄝˋ");
  checkEq(&container, &c, "jees", "ㄐㄧㄝ˙");
  checkEq(&container, &c, "jew", "ㄐㄧㄠ");
  checkEq(&container, &c, "jewd", "ㄐㄧㄠˊ");
  checkEq(&container, &c, "jewf", "ㄐㄧㄠˇ");
  checkEq(&container, &c, "jewj", "ㄐㄧㄠˋ");
  checkEq(&container, &c, "jeo", "ㄐㄧㄡ");
  checkEq(&container, &c, "jeof", "ㄐㄧㄡˇ");
  checkEq(&container, &c, "jeoj", "ㄐㄧㄡˋ");
  checkEq(&container, &c, "jem", "ㄐㄧㄢ");
  checkEq(&container, &c, "jemf", "ㄐㄧㄢˇ");
  checkEq(&container, &c, "jemj", "ㄐㄧㄢˋ");
  checkEq(&container, &c, "jen", "ㄐㄧㄣ");
  checkEq(&container, &c, "jenf", "ㄐㄧㄣˇ");
  checkEq(&container, &c, "jenj", "ㄐㄧㄣˋ");
  checkEq(&container, &c, "jek", "ㄐㄧㄤ");
  checkEq(&container, &c, "jekd", "ㄐㄧㄤˊ");
  checkEq(&container, &c, "jekf", "ㄐㄧㄤˇ");
  checkEq(&container, &c, "jekj", "ㄐㄧㄤˋ");
  checkEq(&container, &c, "jel", "ㄐㄧㄥ");
  checkEq(&container, &c, "jelf", "ㄐㄧㄥˇ");
  checkEq(&container, &c, "jelj", "ㄐㄧㄥˋ");
  checkEq(&container, &c, "ju", "ㄐㄩ");
  checkEq(&container, &c, "jud", "ㄐㄩˊ");
  checkEq(&container, &c, "juf", "ㄐㄩˇ");
  checkEq(&container, &c, "juj", "ㄐㄩˋ");
  checkEq(&container, &c, "jue", "ㄐㄩㄝ");
  checkEq(&container, &c, "jued", "ㄐㄩㄝˊ");
  checkEq(&container, &c, "juef", "ㄐㄩㄝˇ");
  checkEq(&container, &c, "juej", "ㄐㄩㄝˋ");
  checkEq(&container, &c, "jum", "ㄐㄩㄢ");
  checkEq(&container, &c, "jumf", "ㄐㄩㄢˇ");
  checkEq(&container, &c, "jumj", "ㄐㄩㄢˋ");
  checkEq(&container, &c, "jun", "ㄐㄩㄣ");
  checkEq(&container, &c, "jund", "ㄐㄩㄣˊ");
  checkEq(&container, &c, "junf", "ㄐㄩㄣˇ");
  checkEq(&container, &c, "junj", "ㄐㄩㄣˋ");
  checkEq(&container, &c, "jul", "ㄐㄩㄥ");
  checkEq(&container, &c, "julf", "ㄐㄩㄥˇ");
  checkEq(&container, &c, "julj", "ㄐㄩㄥˋ");
  checkEq(&container, &c, "vs", "ㄑ˙");
  checkEq(&container, &c, "ve", "ㄑㄧ");
  checkEq(&container, &c, "ved", "ㄑㄧˊ");
  checkEq(&container, &c, "vef", "ㄑㄧˇ");
  checkEq(&container, &c, "vej", "ㄑㄧˋ");
  checkEq(&container, &c, "vey", "ㄑㄧㄚ");
  checkEq(&container, &c, "veyd", "ㄑㄧㄚˊ");
  checkEq(&container, &c, "veyf", "ㄑㄧㄚˇ");
  checkEq(&container, &c, "veyj", "ㄑㄧㄚˋ");
  checkEq(&container, &c, "vee", "ㄑㄧㄝ");
  checkEq(&container, &c, "veed", "ㄑㄧㄝˊ");
  checkEq(&container, &c, "veef", "ㄑㄧㄝˇ");
  checkEq(&container, &c, "veej", "ㄑㄧㄝˋ");
  checkEq(&container, &c, "vew", "ㄑㄧㄠ");
  checkEq(&container, &c, "vewd", "ㄑㄧㄠˊ");
  checkEq(&container, &c, "vewf", "ㄑㄧㄠˇ");
  checkEq(&container, &c, "vewj", "ㄑㄧㄠˋ");
  checkEq(&container, &c, "veo", "ㄑㄧㄡ");
  checkEq(&container, &c, "veod", "ㄑㄧㄡˊ");
  checkEq(&container, &c, "veof", "ㄑㄧㄡˇ");
  checkEq(&container, &c, "veoj", "ㄑㄧㄡˋ");
  checkEq(&container, &c, "vem", "ㄑㄧㄢ");
  checkEq(&container, &c, "vemd", "ㄑㄧㄢˊ");
  checkEq(&container, &c, "vemf", "ㄑㄧㄢˇ");
  checkEq(&container, &c, "vemj", "ㄑㄧㄢˋ");
  checkEq(&container, &c, "ven", "ㄑㄧㄣ");
  checkEq(&container, &c, "vend", "ㄑㄧㄣˊ");
  checkEq(&container, &c, "venf", "ㄑㄧㄣˇ");
  checkEq(&container, &c, "venj", "ㄑㄧㄣˋ");
  checkEq(&container, &c, "vek", "ㄑㄧㄤ");
  checkEq(&container, &c, "vekd", "ㄑㄧㄤˊ");
  checkEq(&container, &c, "vekf", "ㄑㄧㄤˇ");
  checkEq(&container, &c, "vekj", "ㄑㄧㄤˋ");
  checkEq(&container, &c, "vel", "ㄑㄧㄥ");
  checkEq(&container, &c, "veld", "ㄑㄧㄥˊ");
  checkEq(&container, &c, "velf", "ㄑㄧㄥˇ");
  checkEq(&container, &c, "velj", "ㄑㄧㄥˋ");
  checkEq(&container, &c, "vu", "ㄑㄩ");
  checkEq(&container, &c, "vud", "ㄑㄩˊ");
  checkEq(&container, &c, "vuf", "ㄑㄩˇ");
  checkEq(&container, &c, "vuj", "ㄑㄩˋ");
  checkEq(&container, &c, "vue", "ㄑㄩㄝ");
  checkEq(&container, &c, "vued", "ㄑㄩㄝˊ");
  checkEq(&container, &c, "vuej", "ㄑㄩㄝˋ");
  checkEq(&container, &c, "vum", "ㄑㄩㄢ");
  checkEq(&container, &c, "vumd", "ㄑㄩㄢˊ");
  checkEq(&container, &c, "vumf", "ㄑㄩㄢˇ");
  checkEq(&container, &c, "vumj", "ㄑㄩㄢˋ");
  checkEq(&container, &c, "vun", "ㄑㄩㄣ");
  checkEq(&container, &c, "vund", "ㄑㄩㄣˊ");
  checkEq(&container, &c, "vunf", "ㄑㄩㄣˇ");
  checkEq(&container, &c, "vunj", "ㄑㄩㄣˋ");
  checkEq(&container, &c, "vul", "ㄑㄩㄥ");
  checkEq(&container, &c, "vuld", "ㄑㄩㄥˊ");
  checkEq(&container, &c, "vulf", "ㄑㄩㄥˇ");
  checkEq(&container, &c, "vulj", "ㄑㄩㄥˋ");
  checkEq(&container, &c, "ce", "ㄒㄧ");
  checkEq(&container, &c, "ced", "ㄒㄧˊ");
  checkEq(&container, &c, "cef", "ㄒㄧˇ");
  checkEq(&container, &c, "cej", "ㄒㄧˋ");
  checkEq(&container, &c, "cey", "ㄒㄧㄚ");
  checkEq(&container, &c, "ceyd", "ㄒㄧㄚˊ");
  checkEq(&container, &c, "ceyf", "ㄒㄧㄚˇ");
  checkEq(&container, &c, "ceyj", "ㄒㄧㄚˋ");
  checkEq(&container, &c, "cee", "ㄒㄧㄝ");
  checkEq(&container, &c, "ceed", "ㄒㄧㄝˊ");
  checkEq(&container, &c, "ceef", "ㄒㄧㄝˇ");
  checkEq(&container, &c, "ceej", "ㄒㄧㄝˋ");
  checkEq(&container, &c, "cew", "ㄒㄧㄠ");
  checkEq(&container, &c, "cewd", "ㄒㄧㄠˊ");
  checkEq(&container, &c, "cewf", "ㄒㄧㄠˇ");
  checkEq(&container, &c, "cewj", "ㄒㄧㄠˋ");
  checkEq(&container, &c, "ceo", "ㄒㄧㄡ");
  checkEq(&container, &c, "ceod", "ㄒㄧㄡˊ");
  checkEq(&container, &c, "ceof", "ㄒㄧㄡˇ");
  checkEq(&container, &c, "ceoj", "ㄒㄧㄡˋ");
  checkEq(&container, &c, "cem", "ㄒㄧㄢ");
  checkEq(&container, &c, "cemd", "ㄒㄧㄢˊ");
  checkEq(&container, &c, "cemf", "ㄒㄧㄢˇ");
  checkEq(&container, &c, "cemj", "ㄒㄧㄢˋ");
  checkEq(&container, &c, "cen", "ㄒㄧㄣ");
  checkEq(&container, &c, "cend", "ㄒㄧㄣˊ");
  checkEq(&container, &c, "cenf", "ㄒㄧㄣˇ");
  checkEq(&container, &c, "cenj", "ㄒㄧㄣˋ");
  checkEq(&container, &c, "cek", "ㄒㄧㄤ");
  checkEq(&container, &c, "cekd", "ㄒㄧㄤˊ");
  checkEq(&container, &c, "cekf", "ㄒㄧㄤˇ");
  checkEq(&container, &c, "cekj", "ㄒㄧㄤˋ");
  checkEq(&container, &c, "cel", "ㄒㄧㄥ");
  checkEq(&container, &c, "celd", "ㄒㄧㄥˊ");
  checkEq(&container, &c, "celf", "ㄒㄧㄥˇ");
  checkEq(&container, &c, "celj", "ㄒㄧㄥˋ");
  checkEq(&container, &c, "cu", "ㄒㄩ");
  checkEq(&container, &c, "cud", "ㄒㄩˊ");
  checkEq(&container, &c, "cuf", "ㄒㄩˇ");
  checkEq(&container, &c, "cuj", "ㄒㄩˋ");
  checkEq(&container, &c, "cue", "ㄒㄩㄝ");
  checkEq(&container, &c, "cued", "ㄒㄩㄝˊ");
  checkEq(&container, &c, "cuef", "ㄒㄩㄝˇ");
  checkEq(&container, &c, "cuej", "ㄒㄩㄝˋ");
  checkEq(&container, &c, "cum", "ㄒㄩㄢ");
  checkEq(&container, &c, "cumd", "ㄒㄩㄢˊ");
  checkEq(&container, &c, "cumf", "ㄒㄩㄢˇ");
  checkEq(&container, &c, "cumj", "ㄒㄩㄢˋ");
  checkEq(&container, &c, "cun", "ㄒㄩㄣ");
  checkEq(&container, &c, "cund", "ㄒㄩㄣˊ");
  checkEq(&container, &c, "cunj", "ㄒㄩㄣˋ");
  checkEq(&container, &c, "cul", "ㄒㄩㄥ");
  checkEq(&container, &c, "culd", "ㄒㄩㄥˊ");
  checkEq(&container, &c, "culf", "ㄒㄩㄥˇ");
  checkEq(&container, &c, "culj", "ㄒㄩㄥˋ");
  checkEq(&container, &c, "j", "ㄓ");
  checkEq(&container, &c, "jd", "ㄓˊ");
  checkEq(&container, &c, "jf", "ㄓˇ");
  checkEq(&container, &c, "jj", "ㄓˋ");
  checkEq(&container, &c, "jy", "ㄓㄚ");
  checkEq(&container, &c, "jyd", "ㄓㄚˊ");
  checkEq(&container, &c, "jyf", "ㄓㄚˇ");
  checkEq(&container, &c, "jyj", "ㄓㄚˋ");
  checkEq(&container, &c, "jg", "ㄓㄜ");
  checkEq(&container, &c, "jgd", "ㄓㄜˊ");
  checkEq(&container, &c, "jgf", "ㄓㄜˇ");
  checkEq(&container, &c, "jgj", "ㄓㄜˋ");
  checkEq(&container, &c, "jgs", "ㄓㄜ˙");
  checkEq(&container, &c, "ji", "ㄓㄞ");
  checkEq(&container, &c, "jid", "ㄓㄞˊ");
  checkEq(&container, &c, "jif", "ㄓㄞˇ");
  checkEq(&container, &c, "jij", "ㄓㄞˋ");
  checkEq(&container, &c, "jaj", "ㄓㄟˋ");
  checkEq(&container, &c, "jw", "ㄓㄠ");
  checkEq(&container, &c, "jwd", "ㄓㄠˊ");
  checkEq(&container, &c, "jwf", "ㄓㄠˇ");
  checkEq(&container, &c, "jwj", "ㄓㄠˋ");
  checkEq(&container, &c, "jo", "ㄓㄡ");
  checkEq(&container, &c, "jod", "ㄓㄡˊ");
  checkEq(&container, &c, "jof", "ㄓㄡˇ");
  checkEq(&container, &c, "joj", "ㄓㄡˋ");
  checkEq(&container, &c, "jm", "ㄓㄢ");
  checkEq(&container, &c, "jmf", "ㄓㄢˇ");
  checkEq(&container, &c, "jmj", "ㄓㄢˋ");
  checkEq(&container, &c, "jn", "ㄓㄣ");
  checkEq(&container, &c, "jnd", "ㄓㄣˊ");
  checkEq(&container, &c, "jnf", "ㄓㄣˇ");
  checkEq(&container, &c, "jnj", "ㄓㄣˋ");
  checkEq(&container, &c, "jk", "ㄓㄤ");
  checkEq(&container, &c, "jkf", "ㄓㄤˇ");
  checkEq(&container, &c, "jkj", "ㄓㄤˋ");
  checkEq(&container, &c, "jl", "ㄓㄥ");
  checkEq(&container, &c, "jlf", "ㄓㄥˇ");
  checkEq(&container, &c, "jlj", "ㄓㄥˋ");
  checkEq(&container, &c, "jx", "ㄓㄨ");
  checkEq(&container, &c, "jxd", "ㄓㄨˊ");
  checkEq(&container, &c, "jxf", "ㄓㄨˇ");
  checkEq(&container, &c, "jxj", "ㄓㄨˋ");
  checkEq(&container, &c, "jxy", "ㄓㄨㄚ");
  checkEq(&container, &c, "jxyf", "ㄓㄨㄚˇ");
  checkEq(&container, &c, "jxh", "ㄓㄨㄛ");
  checkEq(&container, &c, "jxhd", "ㄓㄨㄛˊ");
  checkEq(&container, &c, "jxhj", "ㄓㄨㄛˋ");
  checkEq(&container, &c, "jxi", "ㄓㄨㄞ");
  checkEq(&container, &c, "jxif", "ㄓㄨㄞˇ");
  checkEq(&container, &c, "jxij", "ㄓㄨㄞˋ");
  checkEq(&container, &c, "jxa", "ㄓㄨㄟ");
  checkEq(&container, &c, "jxaf", "ㄓㄨㄟˇ");
  checkEq(&container, &c, "jxaj", "ㄓㄨㄟˋ");
  checkEq(&container, &c, "jxm", "ㄓㄨㄢ");
  checkEq(&container, &c, "jxmf", "ㄓㄨㄢˇ");
  checkEq(&container, &c, "jxmj", "ㄓㄨㄢˋ");
  checkEq(&container, &c, "jxn", "ㄓㄨㄣ");
  checkEq(&container, &c, "jxnf", "ㄓㄨㄣˇ");
  checkEq(&container, &c, "jxnj", "ㄓㄨㄣˋ");
  checkEq(&container, &c, "jxk", "ㄓㄨㄤ");
  checkEq(&container, &c, "jxkf", "ㄓㄨㄤˇ");
  checkEq(&container, &c, "jxkj", "ㄓㄨㄤˋ");
  checkEq(&container, &c, "jxl", "ㄓㄨㄥ");
  checkEq(&container, &c, "jxlf", "ㄓㄨㄥˇ");
  checkEq(&container, &c, "jxlj", "ㄓㄨㄥˋ");
  checkEq(&container, &c, "v ", "ㄔ ");
  checkEq(&container, &c, "vd", "ㄔˊ");
  checkEq(&container, &c, "vf", "ㄔˇ");
  checkEq(&container, &c, "vj", "ㄔˋ");
  checkEq(&container, &c, "vy", "ㄔㄚ");
  checkEq(&container, &c, "vyd", "ㄔㄚˊ");
  checkEq(&container, &c, "vyf", "ㄔㄚˇ");
  checkEq(&container, &c, "vyj", "ㄔㄚˋ");
  checkEq(&container, &c, "vg ", "ㄔㄜ ");
  checkEq(&container, &c, "vgf", "ㄔㄜˇ");
  checkEq(&container, &c, "vgj", "ㄔㄜˋ");
  checkEq(&container, &c, "vi", "ㄔㄞ");
  checkEq(&container, &c, "vid", "ㄔㄞˊ");
  checkEq(&container, &c, "vif", "ㄔㄞˇ");
  checkEq(&container, &c, "vij", "ㄔㄞˋ");
  checkEq(&container, &c, "vw", "ㄔㄠ");
  checkEq(&container, &c, "vwd", "ㄔㄠˊ");
  checkEq(&container, &c, "vwf", "ㄔㄠˇ");
  checkEq(&container, &c, "vwj", "ㄔㄠˋ");
  checkEq(&container, &c, "vo", "ㄔㄡ");
  checkEq(&container, &c, "vod", "ㄔㄡˊ");
  checkEq(&container, &c, "vof", "ㄔㄡˇ");
  checkEq(&container, &c, "voj", "ㄔㄡˋ");
  checkEq(&container, &c, "vm ", "ㄔㄢ ");
  checkEq(&container, &c, "vmd", "ㄔㄢˊ");
  checkEq(&container, &c, "vmf", "ㄔㄢˇ");
  checkEq(&container, &c, "vmj", "ㄔㄢˋ");
  checkEq(&container, &c, "vn ", "ㄔㄣ ");
  checkEq(&container, &c, "vnd", "ㄔㄣˊ");
  checkEq(&container, &c, "vnf", "ㄔㄣˇ");
  checkEq(&container, &c, "vnj", "ㄔㄣˋ");
  checkEq(&container, &c, "vns", "ㄔㄣ˙");
  checkEq(&container, &c, "vk ", "ㄔㄤ ");
  checkEq(&container, &c, "vkd", "ㄔㄤˊ");
  checkEq(&container, &c, "vkf", "ㄔㄤˇ");
  checkEq(&container, &c, "vkj", "ㄔㄤˋ");
  checkEq(&container, &c, "vl ", "ㄔㄥ ");
  checkEq(&container, &c, "vld", "ㄔㄥˊ");
  checkEq(&container, &c, "vlf", "ㄔㄥˇ");
  checkEq(&container, &c, "vlj", "ㄔㄥˋ");
  checkEq(&container, &c, "vx", "ㄔㄨ");
  checkEq(&container, &c, "vxd", "ㄔㄨˊ");
  checkEq(&container, &c, "vxf", "ㄔㄨˇ");
  checkEq(&container, &c, "vxj", "ㄔㄨˋ");
  checkEq(&container, &c, "vxy", "ㄔㄨㄚ");
  checkEq(&container, &c, "vxyf", "ㄔㄨㄚˇ");
  checkEq(&container, &c, "vxyj", "ㄔㄨㄚˋ");
  checkEq(&container, &c, "vxh", "ㄔㄨㄛ");
  checkEq(&container, &c, "vxhj", "ㄔㄨㄛˋ");
  checkEq(&container, &c, "vxi", "ㄔㄨㄞ");
  checkEq(&container, &c, "vxid", "ㄔㄨㄞˊ");
  checkEq(&container, &c, "vxif", "ㄔㄨㄞˇ");
  checkEq(&container, &c, "vxij", "ㄔㄨㄞˋ");
  checkEq(&container, &c, "vxa", "ㄔㄨㄟ");
  checkEq(&container, &c, "vxad", "ㄔㄨㄟˊ");
  checkEq(&container, &c, "vxaf", "ㄔㄨㄟˇ");
  checkEq(&container, &c, "vxaj", "ㄔㄨㄟˋ");
  checkEq(&container, &c, "vxm", "ㄔㄨㄢ");
  checkEq(&container, &c, "vxmd", "ㄔㄨㄢˊ");
  checkEq(&container, &c, "vxmf", "ㄔㄨㄢˇ");
  checkEq(&container, &c, "vxmj", "ㄔㄨㄢˋ");
  checkEq(&container, &c, "vxn", "ㄔㄨㄣ");
  checkEq(&container, &c, "vxnd", "ㄔㄨㄣˊ");
  checkEq(&container, &c, "vxnf", "ㄔㄨㄣˇ");
  checkEq(&container, &c, "vxk", "ㄔㄨㄤ");
  checkEq(&container, &c, "vxkd", "ㄔㄨㄤˊ");
  checkEq(&container, &c, "vxkf", "ㄔㄨㄤˇ");
  checkEq(&container, &c, "vxkj", "ㄔㄨㄤˋ");
  checkEq(&container, &c, "vxl", "ㄔㄨㄥ");
  checkEq(&container, &c, "vxld", "ㄔㄨㄥˊ");
  checkEq(&container, &c, "vxlf", "ㄔㄨㄥˇ");
  checkEq(&container, &c, "vxlj", "ㄔㄨㄥˋ");
  checkEq(&container, &c, "c", "ㄕ");
  checkEq(&container, &c, "cd", "ㄕˊ");
  checkEq(&container, &c, "cf", "ㄕˇ");
  checkEq(&container, &c, "cj", "ㄕˋ");
  checkEq(&container, &c, "cs", "ㄕ˙");
  checkEq(&container, &c, "cy", "ㄕㄚ");
  checkEq(&container, &c, "cyd", "ㄕㄚˊ");
  checkEq(&container, &c, "cyf", "ㄕㄚˇ");
  checkEq(&container, &c, "cyj", "ㄕㄚˋ");
  checkEq(&container, &c, "cys", "ㄕㄚ˙");
  checkEq(&container, &c, "cg", "ㄕㄜ");
  checkEq(&container, &c, "cgd", "ㄕㄜˊ");
  checkEq(&container, &c, "cgf", "ㄕㄜˇ");
  checkEq(&container, &c, "cgj", "ㄕㄜˋ");
  checkEq(&container, &c, "ci", "ㄕㄞ");
  checkEq(&container, &c, "cif", "ㄕㄞˇ");
  checkEq(&container, &c, "cij", "ㄕㄞˋ");
  checkEq(&container, &c, "cad", "ㄕㄟˊ");
  checkEq(&container, &c, "cw", "ㄕㄠ");
  checkEq(&container, &c, "cwd", "ㄕㄠˊ");
  checkEq(&container, &c, "cwf", "ㄕㄠˇ");
  checkEq(&container, &c, "cwj", "ㄕㄠˋ");
  checkEq(&container, &c, "co", "ㄕㄡ");
  checkEq(&container, &c, "cod", "ㄕㄡˊ");
  checkEq(&container, &c, "cof", "ㄕㄡˇ");
  checkEq(&container, &c, "coj", "ㄕㄡˋ");
  checkEq(&container, &c, "cm", "ㄕㄢ");
  checkEq(&container, &c, "cmd", "ㄕㄢˊ");
  checkEq(&container, &c, "cmf", "ㄕㄢˇ");
  checkEq(&container, &c, "cmj", "ㄕㄢˋ");
  checkEq(&container, &c, "cn", "ㄕㄣ");
  checkEq(&container, &c, "cnd", "ㄕㄣˊ");
  checkEq(&container, &c, "cnf", "ㄕㄣˇ");
  checkEq(&container, &c, "cnj", "ㄕㄣˋ");
  checkEq(&container, &c, "ck", "ㄕㄤ");
  checkEq(&container, &c, "ckf", "ㄕㄤˇ");
  checkEq(&container, &c, "ckj", "ㄕㄤˋ");
  checkEq(&container, &c, "cks", "ㄕㄤ˙");
  checkEq(&container, &c, "cl", "ㄕㄥ");
  checkEq(&container, &c, "cld", "ㄕㄥˊ");
  checkEq(&container, &c, "clf", "ㄕㄥˇ");
  checkEq(&container, &c, "clj", "ㄕㄥˋ");
  checkEq(&container, &c, "cx", "ㄕㄨ");
  checkEq(&container, &c, "cxd", "ㄕㄨˊ");
  checkEq(&container, &c, "cxf", "ㄕㄨˇ");
  checkEq(&container, &c, "cxj", "ㄕㄨˋ");
  checkEq(&container, &c, "cxy", "ㄕㄨㄚ");
  checkEq(&container, &c, "cxyf", "ㄕㄨㄚˇ");
  checkEq(&container, &c, "cxyj", "ㄕㄨㄚˋ");
  checkEq(&container, &c, "cxh", "ㄕㄨㄛ");
  checkEq(&container, &c, "cxhj", "ㄕㄨㄛˋ");
  checkEq(&container, &c, "cxi", "ㄕㄨㄞ");
  checkEq(&container, &c, "cxif", "ㄕㄨㄞˇ");
  checkEq(&container, &c, "cxij", "ㄕㄨㄞˋ");
  checkEq(&container, &c, "cxa", "ㄕㄨㄟ");
  checkEq(&container, &c, "cxad", "ㄕㄨㄟˊ");
  checkEq(&container, &c, "cxaf", "ㄕㄨㄟˇ");
  checkEq(&container, &c, "cxaj", "ㄕㄨㄟˋ");
  checkEq(&container, &c, "cxm", "ㄕㄨㄢ");
  checkEq(&container, &c, "cxmj", "ㄕㄨㄢˋ");
  checkEq(&container, &c, "cxnf", "ㄕㄨㄣˇ");
  checkEq(&container, &c, "cxnj", "ㄕㄨㄣˋ");
  checkEq(&container, &c, "cxk", "ㄕㄨㄤ");
  checkEq(&container, &c, "cxkd", "ㄕㄨㄤˊ");
  checkEq(&container, &c, "cxkf", "ㄕㄨㄤˇ");
  checkEq(&container, &c, "cxkj", "ㄕㄨㄤˋ");
  checkEq(&container, &c, "rj", "ㄖˋ");
  checkEq(&container, &c, "rgf", "ㄖㄜˇ");
  checkEq(&container, &c, "rgj", "ㄖㄜˋ");
  checkEq(&container, &c, "rwd", "ㄖㄠˊ");
  checkEq(&container, &c, "rwf", "ㄖㄠˇ");
  checkEq(&container, &c, "rwj", "ㄖㄠˋ");
  checkEq(&container, &c, "rod", "ㄖㄡˊ");
  checkEq(&container, &c, "rof", "ㄖㄡˇ");
  checkEq(&container, &c, "roj", "ㄖㄡˋ");
  checkEq(&container, &c, "rmd", "ㄖㄢˊ");
  checkEq(&container, &c, "rmf", "ㄖㄢˇ");
  checkEq(&container, &c, "rmj", "ㄖㄢˋ");
  checkEq(&container, &c, "rnd", "ㄖㄣˊ");
  checkEq(&container, &c, "rnf", "ㄖㄣˇ");
  checkEq(&container, &c, "rnj", "ㄖㄣˋ");
  checkEq(&container, &c, "rk", "ㄖㄤ");
  checkEq(&container, &c, "rkd", "ㄖㄤˊ");
  checkEq(&container, &c, "rkf", "ㄖㄤˇ");
  checkEq(&container, &c, "rkj", "ㄖㄤˋ");
  checkEq(&container, &c, "rl", "ㄖㄥ");
  checkEq(&container, &c, "rld", "ㄖㄥˊ");
  checkEq(&container, &c, "rlf", "ㄖㄥˇ");
  checkEq(&container, &c, "rlj", "ㄖㄥˋ");
  checkEq(&container, &c, "rxd", "ㄖㄨˊ");
  checkEq(&container, &c, "rxf", "ㄖㄨˇ");
  checkEq(&container, &c, "rxj", "ㄖㄨˋ");
  checkEq(&container, &c, "rxhd", "ㄖㄨㄛˊ");
  checkEq(&container, &c, "rxhj", "ㄖㄨㄛˋ");
  checkEq(&container, &c, "rxad", "ㄖㄨㄟˊ");
  checkEq(&container, &c, "rxaf", "ㄖㄨㄟˇ");
  checkEq(&container, &c, "rxaj", "ㄖㄨㄟˋ");
  checkEq(&container, &c, "rxmd", "ㄖㄨㄢˊ");
  checkEq(&container, &c, "rxmf", "ㄖㄨㄢˇ");
  checkEq(&container, &c, "rxmj", "ㄖㄨㄢˋ");
  checkEq(&container, &c, "rxnd", "ㄖㄨㄣˊ");
  checkEq(&container, &c, "rxnf", "ㄖㄨㄣˇ");
  checkEq(&container, &c, "rxnj", "ㄖㄨㄣˋ");
  checkEq(&container, &c, "rxld", "ㄖㄨㄥˊ");
  checkEq(&container, &c, "rxlf", "ㄖㄨㄥˇ");
  checkEq(&container, &c, "rxlj", "ㄖㄨㄥˋ");
  checkEq(&container, &c, "z", "ㄗ");
  checkEq(&container, &c, "zd", "ㄗˊ");
  checkEq(&container, &c, "zf", "ㄗˇ");
  checkEq(&container, &c, "zj", "ㄗˋ");
  checkEq(&container, &c, "zs", "ㄗ˙");
  checkEq(&container, &c, "zy", "ㄗㄚ");
  checkEq(&container, &c, "zyd", "ㄗㄚˊ");
  checkEq(&container, &c, "zyf", "ㄗㄚˇ");
  checkEq(&container, &c, "zgd", "ㄗㄜˊ");
  checkEq(&container, &c, "zgf", "ㄗㄜˇ");
  checkEq(&container, &c, "zgj", "ㄗㄜˋ");
  checkEq(&container, &c, "zi", "ㄗㄞ");
  checkEq(&container, &c, "zif", "ㄗㄞˇ");
  checkEq(&container, &c, "zij", "ㄗㄞˋ");
  checkEq(&container, &c, "zad", "ㄗㄟˊ");
  checkEq(&container, &c, "zw", "ㄗㄠ");
  checkEq(&container, &c, "zwd", "ㄗㄠˊ");
  checkEq(&container, &c, "zwf", "ㄗㄠˇ");
  checkEq(&container, &c, "zwj", "ㄗㄠˋ");
  checkEq(&container, &c, "zo", "ㄗㄡ");
  checkEq(&container, &c, "zof", "ㄗㄡˇ");
  checkEq(&container, &c, "zoj", "ㄗㄡˋ");
  checkEq(&container, &c, "zm", "ㄗㄢ");
  checkEq(&container, &c, "zmd", "ㄗㄢˊ");
  checkEq(&container, &c, "zmf", "ㄗㄢˇ");
  checkEq(&container, &c, "zmj", "ㄗㄢˋ");
  checkEq(&container, &c, "zn", "ㄗㄣ");
  checkEq(&container, &c, "znf", "ㄗㄣˇ");
  checkEq(&container, &c, "znj", "ㄗㄣˋ");
  checkEq(&container, &c, "zk", "ㄗㄤ");
  checkEq(&container, &c, "zkf", "ㄗㄤˇ");
  checkEq(&container, &c, "zkj", "ㄗㄤˋ");
  checkEq(&container, &c, "zl", "ㄗㄥ");
  checkEq(&container, &c, "zlf", "ㄗㄥˇ");
  checkEq(&container, &c, "zlj", "ㄗㄥˋ");
  checkEq(&container, &c, "zx", "ㄗㄨ");
  checkEq(&container, &c, "zxd", "ㄗㄨˊ");
  checkEq(&container, &c, "zxf", "ㄗㄨˇ");
  checkEq(&container, &c, "zxj", "ㄗㄨˋ");
  checkEq(&container, &c, "zxh", "ㄗㄨㄛ");
  checkEq(&container, &c, "zxhd", "ㄗㄨㄛˊ");
  checkEq(&container, &c, "zxhf", "ㄗㄨㄛˇ");
  checkEq(&container, &c, "zxhj", "ㄗㄨㄛˋ");
  checkEq(&container, &c, "zxhs", "ㄗㄨㄛ˙");
  checkEq(&container, &c, "zxa", "ㄗㄨㄟ");
  checkEq(&container, &c, "zxaf", "ㄗㄨㄟˇ");
  checkEq(&container, &c, "zxaj", "ㄗㄨㄟˋ");
  checkEq(&container, &c, "zxm", "ㄗㄨㄢ");
  checkEq(&container, &c, "zxmf", "ㄗㄨㄢˇ");
  checkEq(&container, &c, "zxmj", "ㄗㄨㄢˋ");
  checkEq(&container, &c, "zxn", "ㄗㄨㄣ");
  checkEq(&container, &c, "zxnf", "ㄗㄨㄣˇ");
  checkEq(&container, &c, "zxnj", "ㄗㄨㄣˋ");
  checkEq(&container, &c, "zxl", "ㄗㄨㄥ");
  checkEq(&container, &c, "zxlf", "ㄗㄨㄥˇ");
  checkEq(&container, &c, "zxlj", "ㄗㄨㄥˋ");
  checkEq(&container, &c, "a", "ㄘ");
  checkEq(&container, &c, "ad", "ㄘˊ");
  checkEq(&container, &c, "af", "ㄘˇ");
  checkEq(&container, &c, "aj", "ㄘˋ");
  checkEq(&container, &c, "ay", "ㄘㄚ");
  checkEq(&container, &c, "ayf", "ㄘㄚˇ");
  checkEq(&container, &c, "ayj", "ㄘㄚˋ");
  checkEq(&container, &c, "agj", "ㄘㄜˋ");
  checkEq(&container, &c, "ai", "ㄘㄞ");
  checkEq(&container, &c, "aid", "ㄘㄞˊ");
  checkEq(&container, &c, "aif", "ㄘㄞˇ");
  checkEq(&container, &c, "aij", "ㄘㄞˋ");
  checkEq(&container, &c, "aw", "ㄘㄠ");
  checkEq(&container, &c, "awd", "ㄘㄠˊ");
  checkEq(&container, &c, "awf", "ㄘㄠˇ");
  checkEq(&container, &c, "awj", "ㄘㄠˋ");
  checkEq(&container, &c, "ao", "ㄘㄡ");
  checkEq(&container, &c, "aod", "ㄘㄡˊ");
  checkEq(&container, &c, "aof", "ㄘㄡˇ");
  checkEq(&container, &c, "aoj", "ㄘㄡˋ");
  checkEq(&container, &c, "am", "ㄘㄢ");
  checkEq(&container, &c, "amd", "ㄘㄢˊ");
  checkEq(&container, &c, "amf", "ㄘㄢˇ");
  checkEq(&container, &c, "amj", "ㄘㄢˋ");
  checkEq(&container, &c, "an", "ㄘㄣ");
  checkEq(&container, &c, "and", "ㄘㄣˊ");
  checkEq(&container, &c, "ak", "ㄘㄤ");
  checkEq(&container, &c, "akd", "ㄘㄤˊ");
  checkEq(&container, &c, "akf", "ㄘㄤˇ");
  checkEq(&container, &c, "akj", "ㄘㄤˋ");
  checkEq(&container, &c, "al", "ㄘㄥ");
  checkEq(&container, &c, "ald", "ㄘㄥˊ");
  checkEq(&container, &c, "alf", "ㄘㄥˇ");
  checkEq(&container, &c, "alj", "ㄘㄥˋ");
  checkEq(&container, &c, "ax", "ㄘㄨ");
  checkEq(&container, &c, "axd", "ㄘㄨˊ");
  checkEq(&container, &c, "axf", "ㄘㄨˇ");
  checkEq(&container, &c, "axj", "ㄘㄨˋ");
  checkEq(&container, &c, "axh", "ㄘㄨㄛ");
  checkEq(&container, &c, "axhd", "ㄘㄨㄛˊ");
  checkEq(&container, &c, "axhf", "ㄘㄨㄛˇ");
  checkEq(&container, &c, "axhj", "ㄘㄨㄛˋ");
  checkEq(&container, &c, "axa", "ㄘㄨㄟ");
  checkEq(&container, &c, "axaf", "ㄘㄨㄟˇ");
  checkEq(&container, &c, "axaj", "ㄘㄨㄟˋ");
  checkEq(&container, &c, "axm", "ㄘㄨㄢ");
  checkEq(&container, &c, "axmd", "ㄘㄨㄢˊ");
  checkEq(&container, &c, "axmf", "ㄘㄨㄢˇ");
  checkEq(&container, &c, "axmj", "ㄘㄨㄢˋ");
  checkEq(&container, &c, "axn", "ㄘㄨㄣ");
  checkEq(&container, &c, "axnd", "ㄘㄨㄣˊ");
  checkEq(&container, &c, "axnf", "ㄘㄨㄣˇ");
  checkEq(&container, &c, "axnj", "ㄘㄨㄣˋ");
  checkEq(&container, &c, "axl", "ㄘㄨㄥ");
  checkEq(&container, &c, "axld", "ㄘㄨㄥˊ");
  checkEq(&container, &c, "axlf", "ㄘㄨㄥˇ");
  checkEq(&container, &c, "axlj", "ㄘㄨㄥˋ");
  checkEq(&container, &c, "s", "ㄙ");
  checkEq(&container, &c, "sf", "ㄙˇ");
  checkEq(&container, &c, "sj", "ㄙˋ");
  checkEq(&container, &c, "sy", "ㄙㄚ");
  checkEq(&container, &c, "syf", "ㄙㄚˇ");
  checkEq(&container, &c, "syj", "ㄙㄚˋ");
  checkEq(&container, &c, "sys", "ㄙㄚ˙");
  checkEq(&container, &c, "sg", "ㄙㄜ");
  checkEq(&container, &c, "sgj", "ㄙㄜˋ");
  checkEq(&container, &c, "si", "ㄙㄞ");
  checkEq(&container, &c, "sid", "ㄙㄞˊ");
  checkEq(&container, &c, "sif", "ㄙㄞˇ");
  checkEq(&container, &c, "sij", "ㄙㄞˋ");
  checkEq(&container, &c, "sa", "ㄙㄟ");
  checkEq(&container, &c, "sw", "ㄙㄠ");
  checkEq(&container, &c, "swf", "ㄙㄠˇ");
  checkEq(&container, &c, "swj", "ㄙㄠˋ");
  checkEq(&container, &c, "so", "ㄙㄡ");
  checkEq(&container, &c, "sof", "ㄙㄡˇ");
  checkEq(&container, &c, "soj", "ㄙㄡˋ");
  checkEq(&container, &c, "sm", "ㄙㄢ");
  checkEq(&container, &c, "smf", "ㄙㄢˇ");
  checkEq(&container, &c, "smj", "ㄙㄢˋ");
  checkEq(&container, &c, "sn", "ㄙㄣ");
  checkEq(&container, &c, "snf", "ㄙㄣˇ");
  checkEq(&container, &c, "sk", "ㄙㄤ");
  checkEq(&container, &c, "skf", "ㄙㄤˇ");
  checkEq(&container, &c, "skj", "ㄙㄤˋ");
  checkEq(&container, &c, "sl", "ㄙㄥ");
  checkEq(&container, &c, "slj", "ㄙㄥˋ");
  checkEq(&container, &c, "sx", "ㄙㄨ");
  checkEq(&container, &c, "sxd", "ㄙㄨˊ");
  checkEq(&container, &c, "sxf", "ㄙㄨˇ");
  checkEq(&container, &c, "sxj", "ㄙㄨˋ");
  checkEq(&container, &c, "sxh", "ㄙㄨㄛ");
  checkEq(&container, &c, "sxhd", "ㄙㄨㄛˊ");
  checkEq(&container, &c, "sxhf", "ㄙㄨㄛˇ");
  checkEq(&container, &c, "sxhj", "ㄙㄨㄛˋ");
  checkEq(&container, &c, "sxa", "ㄙㄨㄟ");
  checkEq(&container, &c, "sxad", "ㄙㄨㄟˊ");
  checkEq(&container, &c, "sxaf", "ㄙㄨㄟˇ");
  checkEq(&container, &c, "sxaj", "ㄙㄨㄟˋ");
  checkEq(&container, &c, "sxm", "ㄙㄨㄢ");
  checkEq(&container, &c, "sxmf", "ㄙㄨㄢˇ");
  checkEq(&container, &c, "sxmj", "ㄙㄨㄢˋ");
  checkEq(&container, &c, "sxn", "ㄙㄨㄣ");
  checkEq(&container, &c, "sxnf", "ㄙㄨㄣˇ");
  checkEq(&container, &c, "sxnj", "ㄙㄨㄣˋ");
  checkEq(&container, &c, "sxl", "ㄙㄨㄥ");
  checkEq(&container, &c, "sxld", "ㄙㄨㄥˊ");
  checkEq(&container, &c, "sxlf", "ㄙㄨㄥˇ");
  checkEq(&container, &c, "sxlj", "ㄙㄨㄥˋ");
  checkEq(&container, &c, "y", "ㄚ");
  checkEq(&container, &c, "yd", "ㄚˊ");
  checkEq(&container, &c, "yj", "ㄚˋ");
  checkEq(&container, &c, "ys", "ㄚ˙");
  checkEq(&container, &c, "h ", "ㄛ ");
  checkEq(&container, &c, "hd", "ㄛˊ");
  checkEq(&container, &c, "hf", "ㄛˇ");
  checkEq(&container, &c, "hj", "ㄛˋ");
  checkEq(&container, &c, "g ", "ㄜ ");
  checkEq(&container, &c, "gd", "ㄜˊ");
  checkEq(&container, &c, "gf", "ㄜˇ");
  checkEq(&container, &c, "gj", "ㄜˋ");
  // checkEq(&container, &c, "ed", "ㄝˊ");
  // checkEq(&container, &c, "ef", "ㄝˇ");
  // checkEq(&container, &c, "ej", "ㄝˋ");
  // checkEq(&container, &c, "es", "ㄝ˙");
  checkEq(&container, &c, "i", "ㄞ");
  checkEq(&container, &c, "id", "ㄞˊ");
  checkEq(&container, &c, "if", "ㄞˇ");
  checkEq(&container, &c, "ij", "ㄞˋ");
  // checkEq(&container, &c, "aj", "ㄟˋ");
  checkEq(&container, &c, "w", "ㄠ");
  checkEq(&container, &c, "wd", "ㄠˊ");
  checkEq(&container, &c, "wf", "ㄠˇ");
  checkEq(&container, &c, "wj", "ㄠˋ");
  checkEq(&container, &c, "o", "ㄡ");
  checkEq(&container, &c, "od", "ㄡˊ");
  checkEq(&container, &c, "of", "ㄡˇ");
  checkEq(&container, &c, "oj", "ㄡˋ");
  checkEq(&container, &c, "os", "ㄡ˙");
  checkEq(&container, &c, "m ", "ㄢ ");
  checkEq(&container, &c, "md", "ㄢˊ");
  checkEq(&container, &c, "mf", "ㄢˇ");
  checkEq(&container, &c, "mj", "ㄢˋ");
  checkEq(&container, &c, "n ", "ㄣ ");
  checkEq(&container, &c, "nd", "ㄣˊ");
  checkEq(&container, &c, "nf", "ㄣˇ");
  checkEq(&container, &c, "nj", "ㄣˋ");
  checkEq(&container, &c, "ns", "ㄣ˙");
  checkEq(&container, &c, "k ", "ㄤ ");
  checkEq(&container, &c, "kd", "ㄤˊ");
  checkEq(&container, &c, "kf", "ㄤˇ");
  checkEq(&container, &c, "kj", "ㄤˋ");
  // checkEq(&container, &c, "l ", "ㄥ ");
  // checkEq(&container, &c, "lj", "ㄥˋ");
  checkEq(&container, &c, "l ", "ㄦ ");
  checkEq(&container, &c, "ld", "ㄦˊ");
  checkEq(&container, &c, "lf", "ㄦˇ");
  checkEq(&container, &c, "lj", "ㄦˋ");
  checkEq(&container, &c, "ls", "ㄦ˙");
  checkEq(&container, &c, "e", "ㄧ");
  checkEq(&container, &c, "ed", "ㄧˊ");
  checkEq(&container, &c, "ef", "ㄧˇ");
  checkEq(&container, &c, "ej", "ㄧˋ");
  checkEq(&container, &c, "ey", "ㄧㄚ");
  checkEq(&container, &c, "eyd", "ㄧㄚˊ");
  checkEq(&container, &c, "eyf", "ㄧㄚˇ");
  checkEq(&container, &c, "eyj", "ㄧㄚˋ");
  checkEq(&container, &c, "eys", "ㄧㄚ˙");
  checkEq(&container, &c, "eh", "ㄧㄛ");
  checkEq(&container, &c, "ehs", "ㄧㄛ˙");
  checkEq(&container, &c, "ee", "ㄧㄝ");
  checkEq(&container, &c, "eed", "ㄧㄝˊ");
  checkEq(&container, &c, "eef", "ㄧㄝˇ");
  checkEq(&container, &c, "eej", "ㄧㄝˋ");
  checkEq(&container, &c, "ees", "ㄧㄝ˙");
  checkEq(&container, &c, "eid", "ㄧㄞˊ");
  checkEq(&container, &c, "ew", "ㄧㄠ");
  checkEq(&container, &c, "ewd", "ㄧㄠˊ");
  checkEq(&container, &c, "ewf", "ㄧㄠˇ");
  checkEq(&container, &c, "ewj", "ㄧㄠˋ");
  checkEq(&container, &c, "eo", "ㄧㄡ");
  checkEq(&container, &c, "eod", "ㄧㄡˊ");
  checkEq(&container, &c, "eof", "ㄧㄡˇ");
  checkEq(&container, &c, "eoj", "ㄧㄡˋ");
  checkEq(&container, &c, "em", "ㄧㄢ");
  checkEq(&container, &c, "emd", "ㄧㄢˊ");
  checkEq(&container, &c, "emf", "ㄧㄢˇ");
  checkEq(&container, &c, "emj", "ㄧㄢˋ");
  checkEq(&container, &c, "en", "ㄧㄣ");
  checkEq(&container, &c, "end", "ㄧㄣˊ");
  checkEq(&container, &c, "enf", "ㄧㄣˇ");
  checkEq(&container, &c, "enj", "ㄧㄣˋ");
  checkEq(&container, &c, "ek", "ㄧㄤ");
  checkEq(&container, &c, "ekd", "ㄧㄤˊ");
  checkEq(&container, &c, "ekf", "ㄧㄤˇ");
  checkEq(&container, &c, "ekj", "ㄧㄤˋ");
  checkEq(&container, &c, "el", "ㄧㄥ");
  checkEq(&container, &c, "eld", "ㄧㄥˊ");
  checkEq(&container, &c, "elf", "ㄧㄥˇ");
  checkEq(&container, &c, "elj", "ㄧㄥˋ");
  checkEq(&container, &c, "x", "ㄨ");
  checkEq(&container, &c, "xd", "ㄨˊ");
  checkEq(&container, &c, "xf", "ㄨˇ");
  checkEq(&container, &c, "xj", "ㄨˋ");
  checkEq(&container, &c, "xy", "ㄨㄚ");
  checkEq(&container, &c, "xyd", "ㄨㄚˊ");
  checkEq(&container, &c, "xyf", "ㄨㄚˇ");
  checkEq(&container, &c, "xyj", "ㄨㄚˋ");
  checkEq(&container, &c, "xys", "ㄨㄚ˙");
  checkEq(&container, &c, "xh", "ㄨㄛ");
  checkEq(&container, &c, "xhf", "ㄨㄛˇ");
  checkEq(&container, &c, "xhj", "ㄨㄛˋ");
  checkEq(&container, &c, "xi", "ㄨㄞ");
  checkEq(&container, &c, "xif", "ㄨㄞˇ");
  checkEq(&container, &c, "xij", "ㄨㄞˋ");
  checkEq(&container, &c, "xa", "ㄨㄟ");
  checkEq(&container, &c, "xad", "ㄨㄟˊ");
  checkEq(&container, &c, "xaf", "ㄨㄟˇ");
  checkEq(&container, &c, "xaj", "ㄨㄟˋ");
  checkEq(&container, &c, "xm", "ㄨㄢ");
  checkEq(&container, &c, "xmd", "ㄨㄢˊ");
  checkEq(&container, &c, "xmf", "ㄨㄢˇ");
  checkEq(&container, &c, "xmj", "ㄨㄢˋ");
  checkEq(&container, &c, "xn", "ㄨㄣ");
  checkEq(&container, &c, "xnd", "ㄨㄣˊ");
  checkEq(&container, &c, "xnf", "ㄨㄣˇ");
  checkEq(&container, &c, "xnj", "ㄨㄣˋ");
  checkEq(&container, &c, "xk", "ㄨㄤ");
  checkEq(&container, &c, "xkd", "ㄨㄤˊ");
  checkEq(&container, &c, "xkf", "ㄨㄤˇ");
  checkEq(&container, &c, "xkj", "ㄨㄤˋ");
  checkEq(&container, &c, "xl", "ㄨㄥ");
  checkEq(&container, &c, "xlf", "ㄨㄥˇ");
  checkEq(&container, &c, "xlj", "ㄨㄥˋ");
  checkEq(&container, &c, "u", "ㄩ");
  checkEq(&container, &c, "ud", "ㄩˊ");
  checkEq(&container, &c, "uf", "ㄩˇ");
  checkEq(&container, &c, "uj", "ㄩˋ");
  checkEq(&container, &c, "ue", "ㄩㄝ");
  checkEq(&container, &c, "uef", "ㄩㄝˇ");
  checkEq(&container, &c, "uej", "ㄩㄝˋ");
  checkEq(&container, &c, "um", "ㄩㄢ");
  checkEq(&container, &c, "umd", "ㄩㄢˊ");
  checkEq(&container, &c, "umf", "ㄩㄢˇ");
  checkEq(&container, &c, "umj", "ㄩㄢˋ");
  checkEq(&container, &c, "un", "ㄩㄣ");
  checkEq(&container, &c, "und", "ㄩㄣˊ");
  checkEq(&container, &c, "unf", "ㄩㄣˇ");
  checkEq(&container, &c, "unj", "ㄩㄣˋ");
  checkEq(&container, &c, "ul", "ㄩㄥ");
  checkEq(&container, &c, "uld", "ㄩㄥˊ");
  checkEq(&container, &c, "ulf", "ㄩㄥˇ");
  checkEq(&container, &c, "ulj", "ㄩㄥˋ");
  ASSERT_TRUE(container.empty());
}

TEST(TekkonTests_Advanced, StarlightKeys) {
  // Testing handleHsu()
  Composer c = Composer("", ofStarlight);
  std::vector<std::string> container = {};
  checkEq(&container, &c, "kik", "ㄎㄧㄤ");
  checkEq(&container, &c, "gif7", "ㄍㄧㄠˊ");
  checkEq(&container, &c, "gin", "ㄍㄧㄣ");
  checkEq(&container, &c, "bik7", "ㄅㄧㄤˊ");
  checkEq(&container, &c, "bik9", "ㄅㄧㄤˋ");
  checkEq(&container, &c, "duk", "ㄉㄨㄤ");
  checkEq(&container, &c, "ba", "ㄅㄚ");
  checkEq(&container, &c, "ba7", "ㄅㄚˊ");
  checkEq(&container, &c, "ba8", "ㄅㄚˇ");
  checkEq(&container, &c, "ba9", "ㄅㄚˋ");
  checkEq(&container, &c, "ba0", "ㄅㄚ˙");
  checkEq(&container, &c, "bo", "ㄅㄛ");
  checkEq(&container, &c, "bo7", "ㄅㄛˊ");
  checkEq(&container, &c, "bo8", "ㄅㄛˇ");
  checkEq(&container, &c, "bo9", "ㄅㄛˋ");
  checkEq(&container, &c, "bo0", "ㄅㄛ˙");
  checkEq(&container, &c, "by", "ㄅㄞ");
  checkEq(&container, &c, "by7", "ㄅㄞˊ");
  checkEq(&container, &c, "by8", "ㄅㄞˇ");
  checkEq(&container, &c, "by9", "ㄅㄞˋ");
  checkEq(&container, &c, "by0", "ㄅㄞ˙");
  checkEq(&container, &c, "bt", "ㄅㄟ");
  checkEq(&container, &c, "bt8", "ㄅㄟˇ");
  checkEq(&container, &c, "bt9", "ㄅㄟˋ");
  checkEq(&container, &c, "bt0", "ㄅㄟ˙");
  checkEq(&container, &c, "bf", "ㄅㄠ");
  checkEq(&container, &c, "bf7", "ㄅㄠˊ");
  checkEq(&container, &c, "bf8", "ㄅㄠˇ");
  checkEq(&container, &c, "bf9", "ㄅㄠˋ");
  checkEq(&container, &c, "bm", "ㄅㄢ");
  checkEq(&container, &c, "bm8", "ㄅㄢˇ");
  checkEq(&container, &c, "bm9", "ㄅㄢˋ");
  checkEq(&container, &c, "bn", "ㄅㄣ");
  checkEq(&container, &c, "bn8", "ㄅㄣˇ");
  checkEq(&container, &c, "bn9", "ㄅㄣˋ");
  checkEq(&container, &c, "bk", "ㄅㄤ");
  checkEq(&container, &c, "bk8", "ㄅㄤˇ");
  checkEq(&container, &c, "bk9", "ㄅㄤˋ");
  checkEq(&container, &c, "bg", "ㄅㄥ");
  checkEq(&container, &c, "bg7", "ㄅㄥˊ");
  checkEq(&container, &c, "bg8", "ㄅㄥˇ");
  checkEq(&container, &c, "bg9", "ㄅㄥˋ");
  checkEq(&container, &c, "bi", "ㄅㄧ");
  checkEq(&container, &c, "bi7", "ㄅㄧˊ");
  checkEq(&container, &c, "bi8", "ㄅㄧˇ");
  checkEq(&container, &c, "bi9", "ㄅㄧˋ");
  checkEq(&container, &c, "bie", "ㄅㄧㄝ");
  checkEq(&container, &c, "bie7", "ㄅㄧㄝˊ");
  checkEq(&container, &c, "bie8", "ㄅㄧㄝˇ");
  checkEq(&container, &c, "bie9", "ㄅㄧㄝˋ");
  checkEq(&container, &c, "bif", "ㄅㄧㄠ");
  checkEq(&container, &c, "bif8", "ㄅㄧㄠˇ");
  checkEq(&container, &c, "bif9", "ㄅㄧㄠˋ");
  checkEq(&container, &c, "bim", "ㄅㄧㄢ");
  checkEq(&container, &c, "bim7", "ㄅㄧㄢˊ");
  checkEq(&container, &c, "bim8", "ㄅㄧㄢˇ");
  checkEq(&container, &c, "bim9", "ㄅㄧㄢˋ");
  checkEq(&container, &c, "bin", "ㄅㄧㄣ");
  checkEq(&container, &c, "bin8", "ㄅㄧㄣˇ");
  checkEq(&container, &c, "bin9", "ㄅㄧㄣˋ");
  checkEq(&container, &c, "big", "ㄅㄧㄥ");
  checkEq(&container, &c, "big8", "ㄅㄧㄥˇ");
  checkEq(&container, &c, "big9", "ㄅㄧㄥˋ");
  checkEq(&container, &c, "bu", "ㄅㄨ");
  checkEq(&container, &c, "bu7", "ㄅㄨˊ");
  checkEq(&container, &c, "bu8", "ㄅㄨˇ");
  checkEq(&container, &c, "bu9", "ㄅㄨˋ");
  checkEq(&container, &c, "pa", "ㄆㄚ");
  checkEq(&container, &c, "pa7", "ㄆㄚˊ");
  checkEq(&container, &c, "pa8", "ㄆㄚˇ");
  checkEq(&container, &c, "pa9", "ㄆㄚˋ");
  checkEq(&container, &c, "pa0", "ㄆㄚ˙");
  checkEq(&container, &c, "po", "ㄆㄛ");
  checkEq(&container, &c, "po7", "ㄆㄛˊ");
  checkEq(&container, &c, "po8", "ㄆㄛˇ");
  checkEq(&container, &c, "po9", "ㄆㄛˋ");
  checkEq(&container, &c, "py", "ㄆㄞ");
  checkEq(&container, &c, "py7", "ㄆㄞˊ");
  checkEq(&container, &c, "py8", "ㄆㄞˇ");
  checkEq(&container, &c, "py9", "ㄆㄞˋ");
  checkEq(&container, &c, "pt", "ㄆㄟ");
  checkEq(&container, &c, "pt7", "ㄆㄟˊ");
  checkEq(&container, &c, "pt8", "ㄆㄟˇ");
  checkEq(&container, &c, "pt9", "ㄆㄟˋ");
  checkEq(&container, &c, "pf", "ㄆㄠ");
  checkEq(&container, &c, "pf7", "ㄆㄠˊ");
  checkEq(&container, &c, "pf8", "ㄆㄠˇ");
  checkEq(&container, &c, "pf9", "ㄆㄠˋ");
  checkEq(&container, &c, "pw", "ㄆㄡ");
  checkEq(&container, &c, "pw7", "ㄆㄡˊ");
  checkEq(&container, &c, "pw8", "ㄆㄡˇ");
  checkEq(&container, &c, "pw9", "ㄆㄡˋ");
  checkEq(&container, &c, "pm", "ㄆㄢ");
  checkEq(&container, &c, "pm7", "ㄆㄢˊ");
  checkEq(&container, &c, "pm8", "ㄆㄢˇ");
  checkEq(&container, &c, "pm9", "ㄆㄢˋ");
  checkEq(&container, &c, "pn", "ㄆㄣ");
  checkEq(&container, &c, "pn7", "ㄆㄣˊ");
  checkEq(&container, &c, "pn8", "ㄆㄣˇ");
  checkEq(&container, &c, "pn9", "ㄆㄣˋ");
  checkEq(&container, &c, "pk", "ㄆㄤ");
  checkEq(&container, &c, "pk7", "ㄆㄤˊ");
  checkEq(&container, &c, "pk8", "ㄆㄤˇ");
  checkEq(&container, &c, "pk9", "ㄆㄤˋ");
  checkEq(&container, &c, "pg", "ㄆㄥ");
  checkEq(&container, &c, "pg7", "ㄆㄥˊ");
  checkEq(&container, &c, "pg8", "ㄆㄥˇ");
  checkEq(&container, &c, "pg9", "ㄆㄥˋ");
  checkEq(&container, &c, "pi", "ㄆㄧ");
  checkEq(&container, &c, "pi7", "ㄆㄧˊ");
  checkEq(&container, &c, "pi8", "ㄆㄧˇ");
  checkEq(&container, &c, "pi9", "ㄆㄧˋ");
  checkEq(&container, &c, "pia", "ㄆㄧㄚ");
  checkEq(&container, &c, "pie", "ㄆㄧㄝ");
  checkEq(&container, &c, "pie8", "ㄆㄧㄝˇ");
  checkEq(&container, &c, "pie9", "ㄆㄧㄝˋ");
  checkEq(&container, &c, "pif", "ㄆㄧㄠ");
  checkEq(&container, &c, "pif7", "ㄆㄧㄠˊ");
  checkEq(&container, &c, "pif8", "ㄆㄧㄠˇ");
  checkEq(&container, &c, "pif9", "ㄆㄧㄠˋ");
  checkEq(&container, &c, "pim", "ㄆㄧㄢ");
  checkEq(&container, &c, "pim7", "ㄆㄧㄢˊ");
  checkEq(&container, &c, "pim8", "ㄆㄧㄢˇ");
  checkEq(&container, &c, "pim9", "ㄆㄧㄢˋ");
  checkEq(&container, &c, "pin", "ㄆㄧㄣ");
  checkEq(&container, &c, "pin7", "ㄆㄧㄣˊ");
  checkEq(&container, &c, "pin8", "ㄆㄧㄣˇ");
  checkEq(&container, &c, "pin9", "ㄆㄧㄣˋ");
  checkEq(&container, &c, "pig", "ㄆㄧㄥ");
  checkEq(&container, &c, "pig7", "ㄆㄧㄥˊ");
  checkEq(&container, &c, "pig8", "ㄆㄧㄥˇ");
  checkEq(&container, &c, "pig9", "ㄆㄧㄥˋ");
  checkEq(&container, &c, "pu", "ㄆㄨ");
  checkEq(&container, &c, "pu7", "ㄆㄨˊ");
  checkEq(&container, &c, "pu8", "ㄆㄨˇ");
  checkEq(&container, &c, "pu9", "ㄆㄨˋ");
  checkEq(&container, &c, "ma", "ㄇㄚ");
  checkEq(&container, &c, "ma7", "ㄇㄚˊ");
  checkEq(&container, &c, "ma8", "ㄇㄚˇ");
  checkEq(&container, &c, "ma9", "ㄇㄚˋ");
  checkEq(&container, &c, "ma0", "ㄇㄚ˙");
  checkEq(&container, &c, "mo", "ㄇㄛ");
  checkEq(&container, &c, "mo7", "ㄇㄛˊ");
  checkEq(&container, &c, "mo8", "ㄇㄛˇ");
  checkEq(&container, &c, "mo9", "ㄇㄛˋ");
  checkEq(&container, &c, "mo0", "ㄇㄛ˙");
  checkEq(&container, &c, "me", "ㄇㄜ");
  checkEq(&container, &c, "me9", "ㄇㄜˋ");
  checkEq(&container, &c, "me0", "ㄇㄜ˙");
  checkEq(&container, &c, "my", "ㄇㄞ");
  checkEq(&container, &c, "my7", "ㄇㄞˊ");
  checkEq(&container, &c, "my8", "ㄇㄞˇ");
  checkEq(&container, &c, "my9", "ㄇㄞˋ");
  checkEq(&container, &c, "mt7", "ㄇㄟˊ");
  checkEq(&container, &c, "mt8", "ㄇㄟˇ");
  checkEq(&container, &c, "mt9", "ㄇㄟˋ");
  checkEq(&container, &c, "mf", "ㄇㄠ");
  checkEq(&container, &c, "mf7", "ㄇㄠˊ");
  checkEq(&container, &c, "mf8", "ㄇㄠˇ");
  checkEq(&container, &c, "mf9", "ㄇㄠˋ");
  checkEq(&container, &c, "mw7", "ㄇㄡˊ");
  checkEq(&container, &c, "mw8", "ㄇㄡˇ");
  checkEq(&container, &c, "mw9", "ㄇㄡˋ");
  checkEq(&container, &c, "mm", "ㄇㄢ");
  checkEq(&container, &c, "mm7", "ㄇㄢˊ");
  checkEq(&container, &c, "mm8", "ㄇㄢˇ");
  checkEq(&container, &c, "mm9", "ㄇㄢˋ");
  checkEq(&container, &c, "mn", "ㄇㄣ");
  checkEq(&container, &c, "mn7", "ㄇㄣˊ");
  checkEq(&container, &c, "mn8", "ㄇㄣˇ");
  checkEq(&container, &c, "mn9", "ㄇㄣˋ");
  checkEq(&container, &c, "mn0", "ㄇㄣ˙");
  checkEq(&container, &c, "mk", "ㄇㄤ");
  checkEq(&container, &c, "mk7", "ㄇㄤˊ");
  checkEq(&container, &c, "mk8", "ㄇㄤˇ");
  checkEq(&container, &c, "mk9", "ㄇㄤˋ");
  checkEq(&container, &c, "mg", "ㄇㄥ");
  checkEq(&container, &c, "mg7", "ㄇㄥˊ");
  checkEq(&container, &c, "mg8", "ㄇㄥˇ");
  checkEq(&container, &c, "mg9", "ㄇㄥˋ");
  checkEq(&container, &c, "mi", "ㄇㄧ");
  checkEq(&container, &c, "mi7", "ㄇㄧˊ");
  checkEq(&container, &c, "mi8", "ㄇㄧˇ");
  checkEq(&container, &c, "mi9", "ㄇㄧˋ");
  checkEq(&container, &c, "mie", "ㄇㄧㄝ");
  checkEq(&container, &c, "mie7", "ㄇㄧㄝˊ");
  checkEq(&container, &c, "mie9", "ㄇㄧㄝˋ");
  checkEq(&container, &c, "mif", "ㄇㄧㄠ");
  checkEq(&container, &c, "mif7", "ㄇㄧㄠˊ");
  checkEq(&container, &c, "mif8", "ㄇㄧㄠˇ");
  checkEq(&container, &c, "mif9", "ㄇㄧㄠˋ");
  checkEq(&container, &c, "miw7", "ㄇㄧㄡˊ");
  checkEq(&container, &c, "miw8", "ㄇㄧㄡˇ");
  checkEq(&container, &c, "miw9", "ㄇㄧㄡˋ");
  checkEq(&container, &c, "mim", "ㄇㄧㄢ");
  checkEq(&container, &c, "mim7", "ㄇㄧㄢˊ");
  checkEq(&container, &c, "mim8", "ㄇㄧㄢˇ");
  checkEq(&container, &c, "mim9", "ㄇㄧㄢˋ");
  checkEq(&container, &c, "min", "ㄇㄧㄣ");
  checkEq(&container, &c, "min7", "ㄇㄧㄣˊ");
  checkEq(&container, &c, "min8", "ㄇㄧㄣˇ");
  checkEq(&container, &c, "mig7", "ㄇㄧㄥˊ");
  checkEq(&container, &c, "mig8", "ㄇㄧㄥˇ");
  checkEq(&container, &c, "mig9", "ㄇㄧㄥˋ");
  checkEq(&container, &c, "mu7", "ㄇㄨˊ");
  checkEq(&container, &c, "mu8", "ㄇㄨˇ");
  checkEq(&container, &c, "mu9", "ㄇㄨˋ");
  checkEq(&container, &c, "fa", "ㄈㄚ");
  checkEq(&container, &c, "fa7", "ㄈㄚˊ");
  checkEq(&container, &c, "fa8", "ㄈㄚˇ");
  checkEq(&container, &c, "fa9", "ㄈㄚˋ");
  checkEq(&container, &c, "fo7", "ㄈㄛˊ");
  checkEq(&container, &c, "ft", "ㄈㄟ");
  checkEq(&container, &c, "ft7", "ㄈㄟˊ");
  checkEq(&container, &c, "ft8", "ㄈㄟˇ");
  checkEq(&container, &c, "ft9", "ㄈㄟˋ");
  checkEq(&container, &c, "fw", "ㄈㄡ");
  checkEq(&container, &c, "fw7", "ㄈㄡˊ");
  checkEq(&container, &c, "fw8", "ㄈㄡˇ");
  checkEq(&container, &c, "fw9", "ㄈㄡˋ");
  checkEq(&container, &c, "fm", "ㄈㄢ");
  checkEq(&container, &c, "fm7", "ㄈㄢˊ");
  checkEq(&container, &c, "fm8", "ㄈㄢˇ");
  checkEq(&container, &c, "fm9", "ㄈㄢˋ");
  checkEq(&container, &c, "fn", "ㄈㄣ");
  checkEq(&container, &c, "fn7", "ㄈㄣˊ");
  checkEq(&container, &c, "fn8", "ㄈㄣˇ");
  checkEq(&container, &c, "fn9", "ㄈㄣˋ");
  checkEq(&container, &c, "fn0", "ㄈㄣ˙");
  checkEq(&container, &c, "fk", "ㄈㄤ");
  checkEq(&container, &c, "fk7", "ㄈㄤˊ");
  checkEq(&container, &c, "fk8", "ㄈㄤˇ");
  checkEq(&container, &c, "fk9", "ㄈㄤˋ");
  checkEq(&container, &c, "fg", "ㄈㄥ");
  checkEq(&container, &c, "fg7", "ㄈㄥˊ");
  checkEq(&container, &c, "fg8", "ㄈㄥˇ");
  checkEq(&container, &c, "fg9", "ㄈㄥˋ");
  checkEq(&container, &c, "fif9", "ㄈㄧㄠˋ");
  checkEq(&container, &c, "fu", "ㄈㄨ");
  checkEq(&container, &c, "fu7", "ㄈㄨˊ");
  checkEq(&container, &c, "fu8", "ㄈㄨˇ");
  checkEq(&container, &c, "fu9", "ㄈㄨˋ");
  checkEq(&container, &c, "da", "ㄉㄚ");
  checkEq(&container, &c, "da7", "ㄉㄚˊ");
  checkEq(&container, &c, "da8", "ㄉㄚˇ");
  checkEq(&container, &c, "da9", "ㄉㄚˋ");
  checkEq(&container, &c, "da0", "ㄉㄚ˙");
  checkEq(&container, &c, "de", "ㄉㄜ");
  checkEq(&container, &c, "de7", "ㄉㄜˊ");
  checkEq(&container, &c, "de0", "ㄉㄜ˙");
  checkEq(&container, &c, "dy", "ㄉㄞ");
  checkEq(&container, &c, "dy8", "ㄉㄞˇ");
  checkEq(&container, &c, "dy9", "ㄉㄞˋ");
  checkEq(&container, &c, "dt8", "ㄉㄟˇ");
  checkEq(&container, &c, "df", "ㄉㄠ");
  checkEq(&container, &c, "df7", "ㄉㄠˊ");
  checkEq(&container, &c, "df8", "ㄉㄠˇ");
  checkEq(&container, &c, "df9", "ㄉㄠˋ");
  checkEq(&container, &c, "dw", "ㄉㄡ");
  checkEq(&container, &c, "dw7", "ㄉㄡˊ");
  checkEq(&container, &c, "dw8", "ㄉㄡˇ");
  checkEq(&container, &c, "dw9", "ㄉㄡˋ");
  checkEq(&container, &c, "dm", "ㄉㄢ");
  checkEq(&container, &c, "dm8", "ㄉㄢˇ");
  checkEq(&container, &c, "dm9", "ㄉㄢˋ");
  checkEq(&container, &c, "dn9", "ㄉㄣˋ");
  checkEq(&container, &c, "dk", "ㄉㄤ");
  checkEq(&container, &c, "dk8", "ㄉㄤˇ");
  checkEq(&container, &c, "dk9", "ㄉㄤˋ");
  checkEq(&container, &c, "dg", "ㄉㄥ");
  checkEq(&container, &c, "dg8", "ㄉㄥˇ");
  checkEq(&container, &c, "dg9", "ㄉㄥˋ");
  checkEq(&container, &c, "di", "ㄉㄧ");
  checkEq(&container, &c, "di7", "ㄉㄧˊ");
  checkEq(&container, &c, "di8", "ㄉㄧˇ");
  checkEq(&container, &c, "di9", "ㄉㄧˋ");
  checkEq(&container, &c, "dia8", "ㄉㄧㄚˇ");
  checkEq(&container, &c, "die", "ㄉㄧㄝ");
  checkEq(&container, &c, "die7", "ㄉㄧㄝˊ");
  checkEq(&container, &c, "die8", "ㄉㄧㄝˇ");
  checkEq(&container, &c, "die9", "ㄉㄧㄝˋ");
  checkEq(&container, &c, "dif", "ㄉㄧㄠ");
  checkEq(&container, &c, "dif8", "ㄉㄧㄠˇ");
  checkEq(&container, &c, "dif9", "ㄉㄧㄠˋ");
  checkEq(&container, &c, "diw", "ㄉㄧㄡ");
  checkEq(&container, &c, "dim", "ㄉㄧㄢ");
  checkEq(&container, &c, "dim7", "ㄉㄧㄢˊ");
  checkEq(&container, &c, "dim8", "ㄉㄧㄢˇ");
  checkEq(&container, &c, "dim9", "ㄉㄧㄢˋ");
  checkEq(&container, &c, "dig", "ㄉㄧㄥ");
  checkEq(&container, &c, "dig7", "ㄉㄧㄥˊ");
  checkEq(&container, &c, "dig8", "ㄉㄧㄥˇ");
  checkEq(&container, &c, "dig9", "ㄉㄧㄥˋ");
  checkEq(&container, &c, "du", "ㄉㄨ");
  checkEq(&container, &c, "du7", "ㄉㄨˊ");
  checkEq(&container, &c, "du8", "ㄉㄨˇ");
  checkEq(&container, &c, "du9", "ㄉㄨˋ");
  checkEq(&container, &c, "duo", "ㄉㄨㄛ");
  checkEq(&container, &c, "duo7", "ㄉㄨㄛˊ");
  checkEq(&container, &c, "duo8", "ㄉㄨㄛˇ");
  checkEq(&container, &c, "duo9", "ㄉㄨㄛˋ");
  checkEq(&container, &c, "duo0", "ㄉㄨㄛ˙");
  checkEq(&container, &c, "dut", "ㄉㄨㄟ");
  checkEq(&container, &c, "dut8", "ㄉㄨㄟˇ");
  checkEq(&container, &c, "dut9", "ㄉㄨㄟˋ");
  checkEq(&container, &c, "dum", "ㄉㄨㄢ");
  checkEq(&container, &c, "dum8", "ㄉㄨㄢˇ");
  checkEq(&container, &c, "dum9", "ㄉㄨㄢˋ");
  checkEq(&container, &c, "dun", "ㄉㄨㄣ");
  checkEq(&container, &c, "dun8", "ㄉㄨㄣˇ");
  checkEq(&container, &c, "dun9", "ㄉㄨㄣˋ");
  checkEq(&container, &c, "dug", "ㄉㄨㄥ");
  checkEq(&container, &c, "dug8", "ㄉㄨㄥˇ");
  checkEq(&container, &c, "dug9", "ㄉㄨㄥˋ");
  checkEq(&container, &c, "ta", "ㄊㄚ");
  checkEq(&container, &c, "ta8", "ㄊㄚˇ");
  checkEq(&container, &c, "ta9", "ㄊㄚˋ");
  checkEq(&container, &c, "te9", "ㄊㄜˋ");
  checkEq(&container, &c, "ty", "ㄊㄞ");
  checkEq(&container, &c, "ty7", "ㄊㄞˊ");
  checkEq(&container, &c, "ty8", "ㄊㄞˇ");
  checkEq(&container, &c, "ty9", "ㄊㄞˋ");
  checkEq(&container, &c, "ty0", "ㄊㄞ˙");
  checkEq(&container, &c, "tf", "ㄊㄠ");
  checkEq(&container, &c, "tf7", "ㄊㄠˊ");
  checkEq(&container, &c, "tf8", "ㄊㄠˇ");
  checkEq(&container, &c, "tf9", "ㄊㄠˋ");
  checkEq(&container, &c, "tf0", "ㄊㄠ˙");
  checkEq(&container, &c, "tw", "ㄊㄡ");
  checkEq(&container, &c, "tw7", "ㄊㄡˊ");
  checkEq(&container, &c, "tw8", "ㄊㄡˇ");
  checkEq(&container, &c, "tw9", "ㄊㄡˋ");
  checkEq(&container, &c, "tw0", "ㄊㄡ˙");
  checkEq(&container, &c, "tm", "ㄊㄢ");
  checkEq(&container, &c, "tm7", "ㄊㄢˊ");
  checkEq(&container, &c, "tm8", "ㄊㄢˇ");
  checkEq(&container, &c, "tm9", "ㄊㄢˋ");
  checkEq(&container, &c, "tk", "ㄊㄤ");
  checkEq(&container, &c, "tk7", "ㄊㄤˊ");
  checkEq(&container, &c, "tk8", "ㄊㄤˇ");
  checkEq(&container, &c, "tk9", "ㄊㄤˋ");
  checkEq(&container, &c, "tg", "ㄊㄥ");
  checkEq(&container, &c, "tg7", "ㄊㄥˊ");
  checkEq(&container, &c, "tg9", "ㄊㄥˋ");
  checkEq(&container, &c, "ti", "ㄊㄧ");
  checkEq(&container, &c, "ti7", "ㄊㄧˊ");
  checkEq(&container, &c, "ti8", "ㄊㄧˇ");
  checkEq(&container, &c, "ti9", "ㄊㄧˋ");
  checkEq(&container, &c, "tie", "ㄊㄧㄝ");
  checkEq(&container, &c, "tie7", "ㄊㄧㄝˊ");
  checkEq(&container, &c, "tie8", "ㄊㄧㄝˇ");
  checkEq(&container, &c, "tie9", "ㄊㄧㄝˋ");
  checkEq(&container, &c, "tif", "ㄊㄧㄠ");
  checkEq(&container, &c, "tif7", "ㄊㄧㄠˊ");
  checkEq(&container, &c, "tif8", "ㄊㄧㄠˇ");
  checkEq(&container, &c, "tif9", "ㄊㄧㄠˋ");
  checkEq(&container, &c, "tim", "ㄊㄧㄢ");
  checkEq(&container, &c, "tim7", "ㄊㄧㄢˊ");
  checkEq(&container, &c, "tim8", "ㄊㄧㄢˇ");
  checkEq(&container, &c, "tim9", "ㄊㄧㄢˋ");
  checkEq(&container, &c, "tig", "ㄊㄧㄥ");
  checkEq(&container, &c, "tig7", "ㄊㄧㄥˊ");
  checkEq(&container, &c, "tig8", "ㄊㄧㄥˇ");
  checkEq(&container, &c, "tig9", "ㄊㄧㄥˋ");
  checkEq(&container, &c, "tu", "ㄊㄨ");
  checkEq(&container, &c, "tu7", "ㄊㄨˊ");
  checkEq(&container, &c, "tu8", "ㄊㄨˇ");
  checkEq(&container, &c, "tu9", "ㄊㄨˋ");
  checkEq(&container, &c, "tuo", "ㄊㄨㄛ");
  checkEq(&container, &c, "tuo7", "ㄊㄨㄛˊ");
  checkEq(&container, &c, "tuo8", "ㄊㄨㄛˇ");
  checkEq(&container, &c, "tuo9", "ㄊㄨㄛˋ");
  checkEq(&container, &c, "tut", "ㄊㄨㄟ");
  checkEq(&container, &c, "tut7", "ㄊㄨㄟˊ");
  checkEq(&container, &c, "tut8", "ㄊㄨㄟˇ");
  checkEq(&container, &c, "tut9", "ㄊㄨㄟˋ");
  checkEq(&container, &c, "tum", "ㄊㄨㄢ");
  checkEq(&container, &c, "tum7", "ㄊㄨㄢˊ");
  checkEq(&container, &c, "tum8", "ㄊㄨㄢˇ");
  checkEq(&container, &c, "tum9", "ㄊㄨㄢˋ");
  checkEq(&container, &c, "tun", "ㄊㄨㄣ");
  checkEq(&container, &c, "tun7", "ㄊㄨㄣˊ");
  checkEq(&container, &c, "tun8", "ㄊㄨㄣˇ");
  checkEq(&container, &c, "tun9", "ㄊㄨㄣˋ");
  checkEq(&container, &c, "tug", "ㄊㄨㄥ");
  checkEq(&container, &c, "tug7", "ㄊㄨㄥˊ");
  checkEq(&container, &c, "tug8", "ㄊㄨㄥˇ");
  checkEq(&container, &c, "tug9", "ㄊㄨㄥˋ");
  checkEq(&container, &c, "na", "ㄋㄚ");
  checkEq(&container, &c, "na7", "ㄋㄚˊ");
  checkEq(&container, &c, "na8", "ㄋㄚˇ");
  checkEq(&container, &c, "na9", "ㄋㄚˋ");
  checkEq(&container, &c, "na0", "ㄋㄚ˙");
  checkEq(&container, &c, "ne9", "ㄋㄜˋ");
  checkEq(&container, &c, "ne0", "ㄋㄜ˙");
  checkEq(&container, &c, "ny7", "ㄋㄞˊ");
  checkEq(&container, &c, "ny8", "ㄋㄞˇ");
  checkEq(&container, &c, "ny9", "ㄋㄞˋ");
  checkEq(&container, &c, "nt7", "ㄋㄟˊ");
  checkEq(&container, &c, "nt8", "ㄋㄟˇ");
  checkEq(&container, &c, "nt9", "ㄋㄟˋ");
  checkEq(&container, &c, "nf", "ㄋㄠ");
  checkEq(&container, &c, "nf7", "ㄋㄠˊ");
  checkEq(&container, &c, "nf8", "ㄋㄠˇ");
  checkEq(&container, &c, "nf9", "ㄋㄠˋ");
  checkEq(&container, &c, "nw7", "ㄋㄡˊ");
  checkEq(&container, &c, "nw8", "ㄋㄡˇ");
  checkEq(&container, &c, "nw9", "ㄋㄡˋ");
  checkEq(&container, &c, "nm", "ㄋㄢ");
  checkEq(&container, &c, "nm7", "ㄋㄢˊ");
  checkEq(&container, &c, "nm8", "ㄋㄢˇ");
  checkEq(&container, &c, "nm9", "ㄋㄢˋ");
  checkEq(&container, &c, "nn8", "ㄋㄣˇ");
  checkEq(&container, &c, "nn9", "ㄋㄣˋ");
  checkEq(&container, &c, "nk", "ㄋㄤ");
  checkEq(&container, &c, "nk7", "ㄋㄤˊ");
  checkEq(&container, &c, "nk8", "ㄋㄤˇ");
  checkEq(&container, &c, "nk9", "ㄋㄤˋ");
  checkEq(&container, &c, "nk0", "ㄋㄤ˙");
  checkEq(&container, &c, "ng7", "ㄋㄥˊ");
  checkEq(&container, &c, "ng8", "ㄋㄥˇ");
  checkEq(&container, &c, "ni", "ㄋㄧ");
  checkEq(&container, &c, "ni7", "ㄋㄧˊ");
  checkEq(&container, &c, "ni8", "ㄋㄧˇ");
  checkEq(&container, &c, "ni9", "ㄋㄧˋ");
  checkEq(&container, &c, "nie", "ㄋㄧㄝ");
  checkEq(&container, &c, "nie7", "ㄋㄧㄝˊ");
  checkEq(&container, &c, "nie9", "ㄋㄧㄝˋ");
  checkEq(&container, &c, "nif8", "ㄋㄧㄠˇ");
  checkEq(&container, &c, "nif9", "ㄋㄧㄠˋ");
  checkEq(&container, &c, "niw", "ㄋㄧㄡ");
  checkEq(&container, &c, "niw7", "ㄋㄧㄡˊ");
  checkEq(&container, &c, "niw8", "ㄋㄧㄡˇ");
  checkEq(&container, &c, "niw9", "ㄋㄧㄡˋ");
  checkEq(&container, &c, "nim", "ㄋㄧㄢ");
  checkEq(&container, &c, "nim7", "ㄋㄧㄢˊ");
  checkEq(&container, &c, "nim8", "ㄋㄧㄢˇ");
  checkEq(&container, &c, "nim9", "ㄋㄧㄢˋ");
  checkEq(&container, &c, "nin", "ㄋㄧㄣ");
  checkEq(&container, &c, "nin7", "ㄋㄧㄣˊ");
  checkEq(&container, &c, "nin8", "ㄋㄧㄣˇ");
  checkEq(&container, &c, "nin9", "ㄋㄧㄣˋ");
  checkEq(&container, &c, "nik7", "ㄋㄧㄤˊ");
  checkEq(&container, &c, "nik8", "ㄋㄧㄤˇ");
  checkEq(&container, &c, "nik9", "ㄋㄧㄤˋ");
  checkEq(&container, &c, "nig7", "ㄋㄧㄥˊ");
  checkEq(&container, &c, "nig8", "ㄋㄧㄥˇ");
  checkEq(&container, &c, "nig9", "ㄋㄧㄥˋ");
  checkEq(&container, &c, "nu7", "ㄋㄨˊ");
  checkEq(&container, &c, "nu8", "ㄋㄨˇ");
  checkEq(&container, &c, "nu9", "ㄋㄨˋ");
  checkEq(&container, &c, "nuo7", "ㄋㄨㄛˊ");
  checkEq(&container, &c, "nuo8", "ㄋㄨㄛˇ");
  checkEq(&container, &c, "nuo9", "ㄋㄨㄛˋ");
  checkEq(&container, &c, "nut7", "ㄋㄨㄟˊ");
  checkEq(&container, &c, "num7", "ㄋㄨㄢˊ");
  checkEq(&container, &c, "num8", "ㄋㄨㄢˇ");
  checkEq(&container, &c, "num9", "ㄋㄨㄢˋ");
  checkEq(&container, &c, "nun7", "ㄋㄨㄣˊ");
  checkEq(&container, &c, "nug7", "ㄋㄨㄥˊ");
  checkEq(&container, &c, "nug8", "ㄋㄨㄥˇ");
  checkEq(&container, &c, "nug9", "ㄋㄨㄥˋ");
  checkEq(&container, &c, "nv7", "ㄋㄩˊ");
  checkEq(&container, &c, "nv8", "ㄋㄩˇ");
  checkEq(&container, &c, "nv9", "ㄋㄩˋ");
  checkEq(&container, &c, "nve9", "ㄋㄩㄝˋ");
  checkEq(&container, &c, "la", "ㄌㄚ");
  checkEq(&container, &c, "la7", "ㄌㄚˊ");
  checkEq(&container, &c, "la8", "ㄌㄚˇ");
  checkEq(&container, &c, "la9", "ㄌㄚˋ");
  checkEq(&container, &c, "la0", "ㄌㄚ˙");
  checkEq(&container, &c, "lo", "ㄌㄛ");
  checkEq(&container, &c, "lo0", "ㄌㄛ˙");
  checkEq(&container, &c, "le", "ㄌㄜ");
  checkEq(&container, &c, "le7", "ㄌㄜˊ");
  checkEq(&container, &c, "le9", "ㄌㄜˋ");
  checkEq(&container, &c, "le0", "ㄌㄜ˙");
  checkEq(&container, &c, "ly7", "ㄌㄞˊ");
  checkEq(&container, &c, "ly8", "ㄌㄞˇ");
  checkEq(&container, &c, "ly9", "ㄌㄞˋ");
  checkEq(&container, &c, "lt", "ㄌㄟ");
  checkEq(&container, &c, "lt7", "ㄌㄟˊ");
  checkEq(&container, &c, "lt8", "ㄌㄟˇ");
  checkEq(&container, &c, "lt9", "ㄌㄟˋ");
  checkEq(&container, &c, "lt0", "ㄌㄟ˙");
  checkEq(&container, &c, "lf", "ㄌㄠ");
  checkEq(&container, &c, "lf7", "ㄌㄠˊ");
  checkEq(&container, &c, "lf8", "ㄌㄠˇ");
  checkEq(&container, &c, "lf9", "ㄌㄠˋ");
  checkEq(&container, &c, "lw", "ㄌㄡ");
  checkEq(&container, &c, "lw7", "ㄌㄡˊ");
  checkEq(&container, &c, "lw8", "ㄌㄡˇ");
  checkEq(&container, &c, "lw9", "ㄌㄡˋ");
  checkEq(&container, &c, "lw0", "ㄌㄡ˙");
  checkEq(&container, &c, "lm7", "ㄌㄢˊ");
  checkEq(&container, &c, "lm8", "ㄌㄢˇ");
  checkEq(&container, &c, "lm9", "ㄌㄢˋ");
  checkEq(&container, &c, "lk", "ㄌㄤ");
  checkEq(&container, &c, "lk7", "ㄌㄤˊ");
  checkEq(&container, &c, "lk8", "ㄌㄤˇ");
  checkEq(&container, &c, "lk9", "ㄌㄤˋ");
  checkEq(&container, &c, "lg", "ㄌㄥ");
  checkEq(&container, &c, "lg7", "ㄌㄥˊ");
  checkEq(&container, &c, "lg8", "ㄌㄥˇ");
  checkEq(&container, &c, "lg9", "ㄌㄥˋ");
  checkEq(&container, &c, "li", "ㄌㄧ");
  checkEq(&container, &c, "li7", "ㄌㄧˊ");
  checkEq(&container, &c, "li8", "ㄌㄧˇ");
  checkEq(&container, &c, "li9", "ㄌㄧˋ");
  checkEq(&container, &c, "li0", "ㄌㄧ˙");
  checkEq(&container, &c, "lia8", "ㄌㄧㄚˇ");
  checkEq(&container, &c, "lie", "ㄌㄧㄝ");
  checkEq(&container, &c, "lie7", "ㄌㄧㄝˊ");
  checkEq(&container, &c, "lie8", "ㄌㄧㄝˇ");
  checkEq(&container, &c, "lie9", "ㄌㄧㄝˋ");
  checkEq(&container, &c, "lif", "ㄌㄧㄠ");
  checkEq(&container, &c, "lif7", "ㄌㄧㄠˊ");
  checkEq(&container, &c, "lif8", "ㄌㄧㄠˇ");
  checkEq(&container, &c, "lif9", "ㄌㄧㄠˋ");
  checkEq(&container, &c, "liw", "ㄌㄧㄡ");
  checkEq(&container, &c, "liw7", "ㄌㄧㄡˊ");
  checkEq(&container, &c, "liw8", "ㄌㄧㄡˇ");
  checkEq(&container, &c, "liw9", "ㄌㄧㄡˋ");
  checkEq(&container, &c, "lim", "ㄌㄧㄢ");
  checkEq(&container, &c, "lim7", "ㄌㄧㄢˊ");
  checkEq(&container, &c, "lim8", "ㄌㄧㄢˇ");
  checkEq(&container, &c, "lim9", "ㄌㄧㄢˋ");
  checkEq(&container, &c, "lin7", "ㄌㄧㄣˊ");
  checkEq(&container, &c, "lin8", "ㄌㄧㄣˇ");
  checkEq(&container, &c, "lin9", "ㄌㄧㄣˋ");
  checkEq(&container, &c, "lik7", "ㄌㄧㄤˊ");
  checkEq(&container, &c, "lik8", "ㄌㄧㄤˇ");
  checkEq(&container, &c, "lik9", "ㄌㄧㄤˋ");
  checkEq(&container, &c, "lig", "ㄌㄧㄥ");
  checkEq(&container, &c, "lig7", "ㄌㄧㄥˊ");
  checkEq(&container, &c, "lig8", "ㄌㄧㄥˇ");
  checkEq(&container, &c, "lig9", "ㄌㄧㄥˋ");
  checkEq(&container, &c, "lu", "ㄌㄨ");
  checkEq(&container, &c, "lu7", "ㄌㄨˊ");
  checkEq(&container, &c, "lu8", "ㄌㄨˇ");
  checkEq(&container, &c, "lu9", "ㄌㄨˋ");
  checkEq(&container, &c, "luo", "ㄌㄨㄛ");
  checkEq(&container, &c, "luo7", "ㄌㄨㄛˊ");
  checkEq(&container, &c, "luo8", "ㄌㄨㄛˇ");
  checkEq(&container, &c, "luo9", "ㄌㄨㄛˋ");
  checkEq(&container, &c, "luo0", "ㄌㄨㄛ˙");
  checkEq(&container, &c, "lum7", "ㄌㄨㄢˊ");
  checkEq(&container, &c, "lum8", "ㄌㄨㄢˇ");
  checkEq(&container, &c, "lum9", "ㄌㄨㄢˋ");
  checkEq(&container, &c, "lun", "ㄌㄨㄣ");
  checkEq(&container, &c, "lun7", "ㄌㄨㄣˊ");
  checkEq(&container, &c, "lun8", "ㄌㄨㄣˇ");
  checkEq(&container, &c, "lun9", "ㄌㄨㄣˋ");
  checkEq(&container, &c, "lug", "ㄌㄨㄥ");
  checkEq(&container, &c, "lug7", "ㄌㄨㄥˊ");
  checkEq(&container, &c, "lug8", "ㄌㄨㄥˇ");
  checkEq(&container, &c, "lug9", "ㄌㄨㄥˋ");
  checkEq(&container, &c, "lv", "ㄌㄩ");
  checkEq(&container, &c, "lv7", "ㄌㄩˊ");
  checkEq(&container, &c, "lv8", "ㄌㄩˇ");
  checkEq(&container, &c, "lv9", "ㄌㄩˋ");
  checkEq(&container, &c, "lve", "ㄌㄩㄝ");
  checkEq(&container, &c, "lve8", "ㄌㄩㄝˇ");
  checkEq(&container, &c, "lve9", "ㄌㄩㄝˋ");
  checkEq(&container, &c, "lvm7", "ㄌㄩㄢˊ");
  checkEq(&container, &c, "lvm8", "ㄌㄩㄢˇ");
  checkEq(&container, &c, "ga", "ㄍㄚ");
  checkEq(&container, &c, "ga7", "ㄍㄚˊ");
  checkEq(&container, &c, "ga8", "ㄍㄚˇ");
  checkEq(&container, &c, "ga9", "ㄍㄚˋ");
  checkEq(&container, &c, "ga0", "ㄍㄚ˙");
  checkEq(&container, &c, "ge", "ㄍㄜ");
  checkEq(&container, &c, "ge7", "ㄍㄜˊ");
  checkEq(&container, &c, "ge8", "ㄍㄜˇ");
  checkEq(&container, &c, "ge9", "ㄍㄜˋ");
  checkEq(&container, &c, "ge0", "ㄍㄜ˙");
  checkEq(&container, &c, "gy", "ㄍㄞ");
  checkEq(&container, &c, "gy8", "ㄍㄞˇ");
  checkEq(&container, &c, "gy9", "ㄍㄞˋ");
  checkEq(&container, &c, "gt8", "ㄍㄟˇ");
  checkEq(&container, &c, "gf", "ㄍㄠ");
  checkEq(&container, &c, "gf8", "ㄍㄠˇ");
  checkEq(&container, &c, "gf9", "ㄍㄠˋ");
  checkEq(&container, &c, "gw", "ㄍㄡ");
  checkEq(&container, &c, "gw8", "ㄍㄡˇ");
  checkEq(&container, &c, "gw9", "ㄍㄡˋ");
  checkEq(&container, &c, "gm", "ㄍㄢ");
  checkEq(&container, &c, "gm8", "ㄍㄢˇ");
  checkEq(&container, &c, "gm9", "ㄍㄢˋ");
  checkEq(&container, &c, "gn", "ㄍㄣ");
  checkEq(&container, &c, "gn7", "ㄍㄣˊ");
  checkEq(&container, &c, "gn8", "ㄍㄣˇ");
  checkEq(&container, &c, "gn9", "ㄍㄣˋ");
  checkEq(&container, &c, "gk", "ㄍㄤ");
  checkEq(&container, &c, "gk8", "ㄍㄤˇ");
  checkEq(&container, &c, "gk9", "ㄍㄤˋ");
  checkEq(&container, &c, "gg", "ㄍㄥ");
  checkEq(&container, &c, "gg8", "ㄍㄥˇ");
  checkEq(&container, &c, "gg9", "ㄍㄥˋ");
  checkEq(&container, &c, "gu", "ㄍㄨ");
  checkEq(&container, &c, "gu7", "ㄍㄨˊ");
  checkEq(&container, &c, "gu8", "ㄍㄨˇ");
  checkEq(&container, &c, "gu9", "ㄍㄨˋ");
  checkEq(&container, &c, "gua", "ㄍㄨㄚ");
  checkEq(&container, &c, "gua7", "ㄍㄨㄚˊ");
  checkEq(&container, &c, "gua8", "ㄍㄨㄚˇ");
  checkEq(&container, &c, "gua9", "ㄍㄨㄚˋ");
  checkEq(&container, &c, "guo", "ㄍㄨㄛ");
  checkEq(&container, &c, "guo7", "ㄍㄨㄛˊ");
  checkEq(&container, &c, "guo8", "ㄍㄨㄛˇ");
  checkEq(&container, &c, "guo9", "ㄍㄨㄛˋ");
  checkEq(&container, &c, "guy", "ㄍㄨㄞ");
  checkEq(&container, &c, "guy8", "ㄍㄨㄞˇ");
  checkEq(&container, &c, "guy9", "ㄍㄨㄞˋ");
  checkEq(&container, &c, "gut", "ㄍㄨㄟ");
  checkEq(&container, &c, "gut8", "ㄍㄨㄟˇ");
  checkEq(&container, &c, "gut9", "ㄍㄨㄟˋ");
  checkEq(&container, &c, "gum", "ㄍㄨㄢ");
  checkEq(&container, &c, "gum8", "ㄍㄨㄢˇ");
  checkEq(&container, &c, "gum9", "ㄍㄨㄢˋ");
  checkEq(&container, &c, "gun", "ㄍㄨㄣ");
  checkEq(&container, &c, "gun8", "ㄍㄨㄣˇ");
  checkEq(&container, &c, "gun9", "ㄍㄨㄣˋ");
  checkEq(&container, &c, "guk", "ㄍㄨㄤ");
  checkEq(&container, &c, "guk8", "ㄍㄨㄤˇ");
  checkEq(&container, &c, "guk9", "ㄍㄨㄤˋ");
  checkEq(&container, &c, "gug", "ㄍㄨㄥ");
  checkEq(&container, &c, "gug7", "ㄍㄨㄥˊ");
  checkEq(&container, &c, "gug8", "ㄍㄨㄥˇ");
  checkEq(&container, &c, "gug9", "ㄍㄨㄥˋ");
  checkEq(&container, &c, "ka", "ㄎㄚ");
  checkEq(&container, &c, "ka8", "ㄎㄚˇ");
  checkEq(&container, &c, "ka9", "ㄎㄚˋ");
  checkEq(&container, &c, "ke", "ㄎㄜ");
  checkEq(&container, &c, "ke7", "ㄎㄜˊ");
  checkEq(&container, &c, "ke8", "ㄎㄜˇ");
  checkEq(&container, &c, "ke9", "ㄎㄜˋ");
  checkEq(&container, &c, "ky", "ㄎㄞ");
  checkEq(&container, &c, "ky8", "ㄎㄞˇ");
  checkEq(&container, &c, "ky9", "ㄎㄞˋ");
  checkEq(&container, &c, "kf", "ㄎㄠ");
  checkEq(&container, &c, "kf8", "ㄎㄠˇ");
  checkEq(&container, &c, "kf9", "ㄎㄠˋ");
  checkEq(&container, &c, "kw", "ㄎㄡ");
  checkEq(&container, &c, "kw8", "ㄎㄡˇ");
  checkEq(&container, &c, "kw9", "ㄎㄡˋ");
  checkEq(&container, &c, "km", "ㄎㄢ");
  checkEq(&container, &c, "km8", "ㄎㄢˇ");
  checkEq(&container, &c, "km9", "ㄎㄢˋ");
  checkEq(&container, &c, "kn", "ㄎㄣ");
  checkEq(&container, &c, "kn8", "ㄎㄣˇ");
  checkEq(&container, &c, "kn9", "ㄎㄣˋ");
  checkEq(&container, &c, "kk", "ㄎㄤ");
  checkEq(&container, &c, "kk7", "ㄎㄤˊ");
  checkEq(&container, &c, "kk8", "ㄎㄤˇ");
  checkEq(&container, &c, "kk9", "ㄎㄤˋ");
  checkEq(&container, &c, "kg", "ㄎㄥ");
  checkEq(&container, &c, "kg8", "ㄎㄥˇ");
  checkEq(&container, &c, "ku", "ㄎㄨ");
  checkEq(&container, &c, "ku7", "ㄎㄨˊ");
  checkEq(&container, &c, "ku8", "ㄎㄨˇ");
  checkEq(&container, &c, "ku9", "ㄎㄨˋ");
  checkEq(&container, &c, "kua", "ㄎㄨㄚ");
  checkEq(&container, &c, "kua8", "ㄎㄨㄚˇ");
  checkEq(&container, &c, "kua9", "ㄎㄨㄚˋ");
  checkEq(&container, &c, "kuo9", "ㄎㄨㄛˋ");
  checkEq(&container, &c, "kuy", "ㄎㄨㄞ");
  checkEq(&container, &c, "kuy8", "ㄎㄨㄞˇ");
  checkEq(&container, &c, "kuy9", "ㄎㄨㄞˋ");
  checkEq(&container, &c, "kut", "ㄎㄨㄟ");
  checkEq(&container, &c, "kut7", "ㄎㄨㄟˊ");
  checkEq(&container, &c, "kut8", "ㄎㄨㄟˇ");
  checkEq(&container, &c, "kut9", "ㄎㄨㄟˋ");
  checkEq(&container, &c, "kum", "ㄎㄨㄢ");
  checkEq(&container, &c, "kum8", "ㄎㄨㄢˇ");
  checkEq(&container, &c, "kum9", "ㄎㄨㄢˋ");
  checkEq(&container, &c, "kun", "ㄎㄨㄣ");
  checkEq(&container, &c, "kun8", "ㄎㄨㄣˇ");
  checkEq(&container, &c, "kun9", "ㄎㄨㄣˋ");
  checkEq(&container, &c, "kuk", "ㄎㄨㄤ");
  checkEq(&container, &c, "kuk7", "ㄎㄨㄤˊ");
  checkEq(&container, &c, "kuk8", "ㄎㄨㄤˇ");
  checkEq(&container, &c, "kuk9", "ㄎㄨㄤˋ");
  checkEq(&container, &c, "kug", "ㄎㄨㄥ");
  checkEq(&container, &c, "kug8", "ㄎㄨㄥˇ");
  checkEq(&container, &c, "kug9", "ㄎㄨㄥˋ");
  checkEq(&container, &c, "ha", "ㄏㄚ");
  checkEq(&container, &c, "ha7", "ㄏㄚˊ");
  checkEq(&container, &c, "ha8", "ㄏㄚˇ");
  checkEq(&container, &c, "he", "ㄏㄜ");
  checkEq(&container, &c, "he7", "ㄏㄜˊ");
  checkEq(&container, &c, "he8", "ㄏㄜˇ");
  checkEq(&container, &c, "he9", "ㄏㄜˋ");
  checkEq(&container, &c, "hy", "ㄏㄞ");
  checkEq(&container, &c, "hy7", "ㄏㄞˊ");
  checkEq(&container, &c, "hy8", "ㄏㄞˇ");
  checkEq(&container, &c, "hy9", "ㄏㄞˋ");
  checkEq(&container, &c, "ht", "ㄏㄟ");
  checkEq(&container, &c, "ht8", "ㄏㄟˇ");
  checkEq(&container, &c, "hf", "ㄏㄠ");
  checkEq(&container, &c, "hf7", "ㄏㄠˊ");
  checkEq(&container, &c, "hf8", "ㄏㄠˇ");
  checkEq(&container, &c, "hf9", "ㄏㄠˋ");
  checkEq(&container, &c, "hw", "ㄏㄡ");
  checkEq(&container, &c, "hw7", "ㄏㄡˊ");
  checkEq(&container, &c, "hw8", "ㄏㄡˇ");
  checkEq(&container, &c, "hw9", "ㄏㄡˋ");
  checkEq(&container, &c, "hm", "ㄏㄢ");
  checkEq(&container, &c, "hm7", "ㄏㄢˊ");
  checkEq(&container, &c, "hm8", "ㄏㄢˇ");
  checkEq(&container, &c, "hm9", "ㄏㄢˋ");
  checkEq(&container, &c, "hn", "ㄏㄣ");
  checkEq(&container, &c, "hn7", "ㄏㄣˊ");
  checkEq(&container, &c, "hn8", "ㄏㄣˇ");
  checkEq(&container, &c, "hn9", "ㄏㄣˋ");
  checkEq(&container, &c, "hk", "ㄏㄤ");
  checkEq(&container, &c, "hk7", "ㄏㄤˊ");
  checkEq(&container, &c, "hk8", "ㄏㄤˇ");
  checkEq(&container, &c, "hk9", "ㄏㄤˋ");
  checkEq(&container, &c, "hg", "ㄏㄥ");
  checkEq(&container, &c, "hg7", "ㄏㄥˊ");
  checkEq(&container, &c, "hg9", "ㄏㄥˋ");
  checkEq(&container, &c, "hu", "ㄏㄨ");
  checkEq(&container, &c, "hu7", "ㄏㄨˊ");
  checkEq(&container, &c, "hu8", "ㄏㄨˇ");
  checkEq(&container, &c, "hu9", "ㄏㄨˋ");
  checkEq(&container, &c, "hua", "ㄏㄨㄚ");
  checkEq(&container, &c, "hua7", "ㄏㄨㄚˊ");
  checkEq(&container, &c, "hua8", "ㄏㄨㄚˇ");
  checkEq(&container, &c, "hua9", "ㄏㄨㄚˋ");
  checkEq(&container, &c, "huo", "ㄏㄨㄛ");
  checkEq(&container, &c, "huo7", "ㄏㄨㄛˊ");
  checkEq(&container, &c, "huo8", "ㄏㄨㄛˇ");
  checkEq(&container, &c, "huo9", "ㄏㄨㄛˋ");
  checkEq(&container, &c, "huo0", "ㄏㄨㄛ˙");
  checkEq(&container, &c, "huy7", "ㄏㄨㄞˊ");
  checkEq(&container, &c, "huy9", "ㄏㄨㄞˋ");
  checkEq(&container, &c, "hut", "ㄏㄨㄟ");
  checkEq(&container, &c, "hut7", "ㄏㄨㄟˊ");
  checkEq(&container, &c, "hut8", "ㄏㄨㄟˇ");
  checkEq(&container, &c, "hut9", "ㄏㄨㄟˋ");
  checkEq(&container, &c, "hum", "ㄏㄨㄢ");
  checkEq(&container, &c, "hum7", "ㄏㄨㄢˊ");
  checkEq(&container, &c, "hum8", "ㄏㄨㄢˇ");
  checkEq(&container, &c, "hum9", "ㄏㄨㄢˋ");
  checkEq(&container, &c, "hun", "ㄏㄨㄣ");
  checkEq(&container, &c, "hun7", "ㄏㄨㄣˊ");
  checkEq(&container, &c, "hun8", "ㄏㄨㄣˇ");
  checkEq(&container, &c, "hun9", "ㄏㄨㄣˋ");
  checkEq(&container, &c, "huk", "ㄏㄨㄤ");
  checkEq(&container, &c, "huk7", "ㄏㄨㄤˊ");
  checkEq(&container, &c, "huk8", "ㄏㄨㄤˇ");
  checkEq(&container, &c, "huk9", "ㄏㄨㄤˋ");
  checkEq(&container, &c, "huk0", "ㄏㄨㄤ˙");
  checkEq(&container, &c, "hug", "ㄏㄨㄥ");
  checkEq(&container, &c, "hug7", "ㄏㄨㄥˊ");
  checkEq(&container, &c, "hug8", "ㄏㄨㄥˇ");
  checkEq(&container, &c, "hug9", "ㄏㄨㄥˋ");
  checkEq(&container, &c, "ji", "ㄐㄧ");
  checkEq(&container, &c, "ji7", "ㄐㄧˊ");
  checkEq(&container, &c, "ji8", "ㄐㄧˇ");
  checkEq(&container, &c, "ji9", "ㄐㄧˋ");
  checkEq(&container, &c, "jia", "ㄐㄧㄚ");
  checkEq(&container, &c, "jia7", "ㄐㄧㄚˊ");
  checkEq(&container, &c, "jia8", "ㄐㄧㄚˇ");
  checkEq(&container, &c, "jia9", "ㄐㄧㄚˋ");
  checkEq(&container, &c, "jie", "ㄐㄧㄝ");
  checkEq(&container, &c, "jie7", "ㄐㄧㄝˊ");
  checkEq(&container, &c, "jie8", "ㄐㄧㄝˇ");
  checkEq(&container, &c, "jie9", "ㄐㄧㄝˋ");
  checkEq(&container, &c, "jie0", "ㄐㄧㄝ˙");
  checkEq(&container, &c, "jif", "ㄐㄧㄠ");
  checkEq(&container, &c, "jif7", "ㄐㄧㄠˊ");
  checkEq(&container, &c, "jif8", "ㄐㄧㄠˇ");
  checkEq(&container, &c, "jif9", "ㄐㄧㄠˋ");
  checkEq(&container, &c, "jiw", "ㄐㄧㄡ");
  checkEq(&container, &c, "jiw8", "ㄐㄧㄡˇ");
  checkEq(&container, &c, "jiw9", "ㄐㄧㄡˋ");
  checkEq(&container, &c, "jim", "ㄐㄧㄢ");
  checkEq(&container, &c, "jim8", "ㄐㄧㄢˇ");
  checkEq(&container, &c, "jim9", "ㄐㄧㄢˋ");
  checkEq(&container, &c, "jin", "ㄐㄧㄣ");
  checkEq(&container, &c, "jin8", "ㄐㄧㄣˇ");
  checkEq(&container, &c, "jin9", "ㄐㄧㄣˋ");
  checkEq(&container, &c, "jik", "ㄐㄧㄤ");
  checkEq(&container, &c, "jik7", "ㄐㄧㄤˊ");
  checkEq(&container, &c, "jik8", "ㄐㄧㄤˇ");
  checkEq(&container, &c, "jik9", "ㄐㄧㄤˋ");
  checkEq(&container, &c, "jig", "ㄐㄧㄥ");
  checkEq(&container, &c, "jig8", "ㄐㄧㄥˇ");
  checkEq(&container, &c, "jig9", "ㄐㄧㄥˋ");
  checkEq(&container, &c, "jv", "ㄐㄩ");
  checkEq(&container, &c, "jv7", "ㄐㄩˊ");
  checkEq(&container, &c, "jv8", "ㄐㄩˇ");
  checkEq(&container, &c, "jv9", "ㄐㄩˋ");
  checkEq(&container, &c, "jve", "ㄐㄩㄝ");
  checkEq(&container, &c, "jve7", "ㄐㄩㄝˊ");
  checkEq(&container, &c, "jve8", "ㄐㄩㄝˇ");
  checkEq(&container, &c, "jve9", "ㄐㄩㄝˋ");
  checkEq(&container, &c, "jvm", "ㄐㄩㄢ");
  checkEq(&container, &c, "jvm8", "ㄐㄩㄢˇ");
  checkEq(&container, &c, "jvm9", "ㄐㄩㄢˋ");
  checkEq(&container, &c, "jvn", "ㄐㄩㄣ");
  checkEq(&container, &c, "jvn7", "ㄐㄩㄣˊ");
  checkEq(&container, &c, "jvn8", "ㄐㄩㄣˇ");
  checkEq(&container, &c, "jvn9", "ㄐㄩㄣˋ");
  checkEq(&container, &c, "jvg", "ㄐㄩㄥ");
  checkEq(&container, &c, "jvg8", "ㄐㄩㄥˇ");
  checkEq(&container, &c, "jvg9", "ㄐㄩㄥˋ");
  // checkEq(&container, &c, "q0", "ㄑ˙");
  checkEq(&container, &c, "qi", "ㄑㄧ");
  checkEq(&container, &c, "qi7", "ㄑㄧˊ");
  checkEq(&container, &c, "qi8", "ㄑㄧˇ");
  checkEq(&container, &c, "qi9", "ㄑㄧˋ");
  checkEq(&container, &c, "qia", "ㄑㄧㄚ");
  checkEq(&container, &c, "qia7", "ㄑㄧㄚˊ");
  checkEq(&container, &c, "qia8", "ㄑㄧㄚˇ");
  checkEq(&container, &c, "qia9", "ㄑㄧㄚˋ");
  checkEq(&container, &c, "qie", "ㄑㄧㄝ");
  checkEq(&container, &c, "qie7", "ㄑㄧㄝˊ");
  checkEq(&container, &c, "qie8", "ㄑㄧㄝˇ");
  checkEq(&container, &c, "qie9", "ㄑㄧㄝˋ");
  checkEq(&container, &c, "qif", "ㄑㄧㄠ");
  checkEq(&container, &c, "qif7", "ㄑㄧㄠˊ");
  checkEq(&container, &c, "qif8", "ㄑㄧㄠˇ");
  checkEq(&container, &c, "qif9", "ㄑㄧㄠˋ");
  checkEq(&container, &c, "qiw", "ㄑㄧㄡ");
  checkEq(&container, &c, "qiw7", "ㄑㄧㄡˊ");
  checkEq(&container, &c, "qiw8", "ㄑㄧㄡˇ");
  checkEq(&container, &c, "qiw9", "ㄑㄧㄡˋ");
  checkEq(&container, &c, "qim", "ㄑㄧㄢ");
  checkEq(&container, &c, "qim7", "ㄑㄧㄢˊ");
  checkEq(&container, &c, "qim8", "ㄑㄧㄢˇ");
  checkEq(&container, &c, "qim9", "ㄑㄧㄢˋ");
  checkEq(&container, &c, "qin", "ㄑㄧㄣ");
  checkEq(&container, &c, "qin7", "ㄑㄧㄣˊ");
  checkEq(&container, &c, "qin8", "ㄑㄧㄣˇ");
  checkEq(&container, &c, "qin9", "ㄑㄧㄣˋ");
  checkEq(&container, &c, "qik", "ㄑㄧㄤ");
  checkEq(&container, &c, "qik7", "ㄑㄧㄤˊ");
  checkEq(&container, &c, "qik8", "ㄑㄧㄤˇ");
  checkEq(&container, &c, "qik9", "ㄑㄧㄤˋ");
  checkEq(&container, &c, "qig", "ㄑㄧㄥ");
  checkEq(&container, &c, "qig7", "ㄑㄧㄥˊ");
  checkEq(&container, &c, "qig8", "ㄑㄧㄥˇ");
  checkEq(&container, &c, "qig9", "ㄑㄧㄥˋ");
  checkEq(&container, &c, "qv", "ㄑㄩ");
  checkEq(&container, &c, "qv7", "ㄑㄩˊ");
  checkEq(&container, &c, "qv8", "ㄑㄩˇ");
  checkEq(&container, &c, "qv9", "ㄑㄩˋ");
  checkEq(&container, &c, "qve", "ㄑㄩㄝ");
  checkEq(&container, &c, "qve7", "ㄑㄩㄝˊ");
  checkEq(&container, &c, "qve9", "ㄑㄩㄝˋ");
  checkEq(&container, &c, "qvm", "ㄑㄩㄢ");
  checkEq(&container, &c, "qvm7", "ㄑㄩㄢˊ");
  checkEq(&container, &c, "qvm8", "ㄑㄩㄢˇ");
  checkEq(&container, &c, "qvm9", "ㄑㄩㄢˋ");
  checkEq(&container, &c, "qvn", "ㄑㄩㄣ");
  checkEq(&container, &c, "qvn7", "ㄑㄩㄣˊ");
  checkEq(&container, &c, "qvn8", "ㄑㄩㄣˇ");
  checkEq(&container, &c, "qvn9", "ㄑㄩㄣˋ");
  checkEq(&container, &c, "qvg", "ㄑㄩㄥ");
  checkEq(&container, &c, "qvg7", "ㄑㄩㄥˊ");
  checkEq(&container, &c, "qvg8", "ㄑㄩㄥˇ");
  checkEq(&container, &c, "qvg9", "ㄑㄩㄥˋ");
  checkEq(&container, &c, "xi", "ㄒㄧ");
  checkEq(&container, &c, "xi7", "ㄒㄧˊ");
  checkEq(&container, &c, "xi8", "ㄒㄧˇ");
  checkEq(&container, &c, "xi9", "ㄒㄧˋ");
  checkEq(&container, &c, "xia", "ㄒㄧㄚ");
  checkEq(&container, &c, "xia7", "ㄒㄧㄚˊ");
  checkEq(&container, &c, "xia8", "ㄒㄧㄚˇ");
  checkEq(&container, &c, "xia9", "ㄒㄧㄚˋ");
  checkEq(&container, &c, "xie", "ㄒㄧㄝ");
  checkEq(&container, &c, "xie7", "ㄒㄧㄝˊ");
  checkEq(&container, &c, "xie8", "ㄒㄧㄝˇ");
  checkEq(&container, &c, "xie9", "ㄒㄧㄝˋ");
  checkEq(&container, &c, "xif", "ㄒㄧㄠ");
  checkEq(&container, &c, "xif7", "ㄒㄧㄠˊ");
  checkEq(&container, &c, "xif8", "ㄒㄧㄠˇ");
  checkEq(&container, &c, "xif9", "ㄒㄧㄠˋ");
  checkEq(&container, &c, "xiw", "ㄒㄧㄡ");
  checkEq(&container, &c, "xiw7", "ㄒㄧㄡˊ");
  checkEq(&container, &c, "xiw8", "ㄒㄧㄡˇ");
  checkEq(&container, &c, "xiw9", "ㄒㄧㄡˋ");
  checkEq(&container, &c, "xim", "ㄒㄧㄢ");
  checkEq(&container, &c, "xim7", "ㄒㄧㄢˊ");
  checkEq(&container, &c, "xim8", "ㄒㄧㄢˇ");
  checkEq(&container, &c, "xim9", "ㄒㄧㄢˋ");
  checkEq(&container, &c, "xin", "ㄒㄧㄣ");
  checkEq(&container, &c, "xin7", "ㄒㄧㄣˊ");
  checkEq(&container, &c, "xin8", "ㄒㄧㄣˇ");
  checkEq(&container, &c, "xin9", "ㄒㄧㄣˋ");
  checkEq(&container, &c, "xik", "ㄒㄧㄤ");
  checkEq(&container, &c, "xik7", "ㄒㄧㄤˊ");
  checkEq(&container, &c, "xik8", "ㄒㄧㄤˇ");
  checkEq(&container, &c, "xik9", "ㄒㄧㄤˋ");
  checkEq(&container, &c, "xig", "ㄒㄧㄥ");
  checkEq(&container, &c, "xig7", "ㄒㄧㄥˊ");
  checkEq(&container, &c, "xig8", "ㄒㄧㄥˇ");
  checkEq(&container, &c, "xig9", "ㄒㄧㄥˋ");
  checkEq(&container, &c, "xv", "ㄒㄩ");
  checkEq(&container, &c, "xv7", "ㄒㄩˊ");
  checkEq(&container, &c, "xv8", "ㄒㄩˇ");
  checkEq(&container, &c, "xv9", "ㄒㄩˋ");
  checkEq(&container, &c, "xve", "ㄒㄩㄝ");
  checkEq(&container, &c, "xve7", "ㄒㄩㄝˊ");
  checkEq(&container, &c, "xve8", "ㄒㄩㄝˇ");
  checkEq(&container, &c, "xve9", "ㄒㄩㄝˋ");
  checkEq(&container, &c, "xvm", "ㄒㄩㄢ");
  checkEq(&container, &c, "xvm7", "ㄒㄩㄢˊ");
  checkEq(&container, &c, "xvm8", "ㄒㄩㄢˇ");
  checkEq(&container, &c, "xvm9", "ㄒㄩㄢˋ");
  checkEq(&container, &c, "xvn", "ㄒㄩㄣ");
  checkEq(&container, &c, "xvn7", "ㄒㄩㄣˊ");
  checkEq(&container, &c, "xvn9", "ㄒㄩㄣˋ");
  checkEq(&container, &c, "xvg", "ㄒㄩㄥ");
  checkEq(&container, &c, "xvg7", "ㄒㄩㄥˊ");
  checkEq(&container, &c, "xvg8", "ㄒㄩㄥˇ");
  checkEq(&container, &c, "xvg9", "ㄒㄩㄥˋ");
  checkEq(&container, &c, "j", "ㄓ");
  checkEq(&container, &c, "j7", "ㄓˊ");
  checkEq(&container, &c, "j8", "ㄓˇ");
  checkEq(&container, &c, "j9", "ㄓˋ");
  checkEq(&container, &c, "ja", "ㄓㄚ");
  checkEq(&container, &c, "ja7", "ㄓㄚˊ");
  checkEq(&container, &c, "ja8", "ㄓㄚˇ");
  checkEq(&container, &c, "ja9", "ㄓㄚˋ");
  checkEq(&container, &c, "je", "ㄓㄜ");
  checkEq(&container, &c, "je7", "ㄓㄜˊ");
  checkEq(&container, &c, "je8", "ㄓㄜˇ");
  checkEq(&container, &c, "je9", "ㄓㄜˋ");
  checkEq(&container, &c, "je0", "ㄓㄜ˙");
  checkEq(&container, &c, "jy", "ㄓㄞ");
  checkEq(&container, &c, "jy7", "ㄓㄞˊ");
  checkEq(&container, &c, "jy8", "ㄓㄞˇ");
  checkEq(&container, &c, "jy9", "ㄓㄞˋ");
  checkEq(&container, &c, "jt9", "ㄓㄟˋ");
  checkEq(&container, &c, "jf", "ㄓㄠ");
  checkEq(&container, &c, "jf7", "ㄓㄠˊ");
  checkEq(&container, &c, "jf8", "ㄓㄠˇ");
  checkEq(&container, &c, "jf9", "ㄓㄠˋ");
  checkEq(&container, &c, "jw", "ㄓㄡ");
  checkEq(&container, &c, "jw7", "ㄓㄡˊ");
  checkEq(&container, &c, "jw8", "ㄓㄡˇ");
  checkEq(&container, &c, "jw9", "ㄓㄡˋ");
  checkEq(&container, &c, "jm", "ㄓㄢ");
  checkEq(&container, &c, "jm8", "ㄓㄢˇ");
  checkEq(&container, &c, "jm9", "ㄓㄢˋ");
  checkEq(&container, &c, "jn", "ㄓㄣ");
  checkEq(&container, &c, "jn7", "ㄓㄣˊ");
  checkEq(&container, &c, "jn8", "ㄓㄣˇ");
  checkEq(&container, &c, "jn9", "ㄓㄣˋ");
  checkEq(&container, &c, "jk", "ㄓㄤ");
  checkEq(&container, &c, "jk8", "ㄓㄤˇ");
  checkEq(&container, &c, "jk9", "ㄓㄤˋ");
  checkEq(&container, &c, "jg", "ㄓㄥ");
  checkEq(&container, &c, "jg8", "ㄓㄥˇ");
  checkEq(&container, &c, "jg9", "ㄓㄥˋ");
  checkEq(&container, &c, "ju", "ㄓㄨ");
  checkEq(&container, &c, "ju7", "ㄓㄨˊ");
  checkEq(&container, &c, "ju8", "ㄓㄨˇ");
  checkEq(&container, &c, "ju9", "ㄓㄨˋ");
  checkEq(&container, &c, "jua", "ㄓㄨㄚ");
  checkEq(&container, &c, "jua8", "ㄓㄨㄚˇ");
  checkEq(&container, &c, "juo", "ㄓㄨㄛ");
  checkEq(&container, &c, "juo7", "ㄓㄨㄛˊ");
  checkEq(&container, &c, "juo9", "ㄓㄨㄛˋ");
  checkEq(&container, &c, "juy", "ㄓㄨㄞ");
  checkEq(&container, &c, "juy8", "ㄓㄨㄞˇ");
  checkEq(&container, &c, "juy9", "ㄓㄨㄞˋ");
  checkEq(&container, &c, "jut", "ㄓㄨㄟ");
  checkEq(&container, &c, "jut8", "ㄓㄨㄟˇ");
  checkEq(&container, &c, "jut9", "ㄓㄨㄟˋ");
  checkEq(&container, &c, "jum", "ㄓㄨㄢ");
  checkEq(&container, &c, "jum8", "ㄓㄨㄢˇ");
  checkEq(&container, &c, "jum9", "ㄓㄨㄢˋ");
  checkEq(&container, &c, "jun", "ㄓㄨㄣ");
  checkEq(&container, &c, "jun8", "ㄓㄨㄣˇ");
  checkEq(&container, &c, "jun9", "ㄓㄨㄣˋ");
  checkEq(&container, &c, "juk", "ㄓㄨㄤ");
  checkEq(&container, &c, "juk8", "ㄓㄨㄤˇ");
  checkEq(&container, &c, "juk9", "ㄓㄨㄤˋ");
  checkEq(&container, &c, "jug", "ㄓㄨㄥ");
  checkEq(&container, &c, "jug8", "ㄓㄨㄥˇ");
  checkEq(&container, &c, "jug9", "ㄓㄨㄥˋ");
  checkEq(&container, &c, "q", "ㄔ");
  checkEq(&container, &c, "q7", "ㄔˊ");
  checkEq(&container, &c, "q8", "ㄔˇ");
  checkEq(&container, &c, "q9", "ㄔˋ");
  checkEq(&container, &c, "qa", "ㄔㄚ");
  checkEq(&container, &c, "qa7", "ㄔㄚˊ");
  checkEq(&container, &c, "qa8", "ㄔㄚˇ");
  checkEq(&container, &c, "qa9", "ㄔㄚˋ");
  checkEq(&container, &c, "qe", "ㄔㄜ");
  checkEq(&container, &c, "qe8", "ㄔㄜˇ");
  checkEq(&container, &c, "qe9", "ㄔㄜˋ");
  checkEq(&container, &c, "qy", "ㄔㄞ");
  checkEq(&container, &c, "qy7", "ㄔㄞˊ");
  checkEq(&container, &c, "qy8", "ㄔㄞˇ");
  checkEq(&container, &c, "qy9", "ㄔㄞˋ");
  checkEq(&container, &c, "qf", "ㄔㄠ");
  checkEq(&container, &c, "qf7", "ㄔㄠˊ");
  checkEq(&container, &c, "qf8", "ㄔㄠˇ");
  checkEq(&container, &c, "qf9", "ㄔㄠˋ");
  checkEq(&container, &c, "qw", "ㄔㄡ");
  checkEq(&container, &c, "qw7", "ㄔㄡˊ");
  checkEq(&container, &c, "qw8", "ㄔㄡˇ");
  checkEq(&container, &c, "qw9", "ㄔㄡˋ");
  checkEq(&container, &c, "qm", "ㄔㄢ");
  checkEq(&container, &c, "qm7", "ㄔㄢˊ");
  checkEq(&container, &c, "qm8", "ㄔㄢˇ");
  checkEq(&container, &c, "qm9", "ㄔㄢˋ");
  checkEq(&container, &c, "qn", "ㄔㄣ");
  checkEq(&container, &c, "qn7", "ㄔㄣˊ");
  checkEq(&container, &c, "qn8", "ㄔㄣˇ");
  checkEq(&container, &c, "qn9", "ㄔㄣˋ");
  checkEq(&container, &c, "qn0", "ㄔㄣ˙");
  checkEq(&container, &c, "qk", "ㄔㄤ");
  checkEq(&container, &c, "qk7", "ㄔㄤˊ");
  checkEq(&container, &c, "qk8", "ㄔㄤˇ");
  checkEq(&container, &c, "qk9", "ㄔㄤˋ");
  checkEq(&container, &c, "qg", "ㄔㄥ");
  checkEq(&container, &c, "qg7", "ㄔㄥˊ");
  checkEq(&container, &c, "qg8", "ㄔㄥˇ");
  checkEq(&container, &c, "qg9", "ㄔㄥˋ");
  checkEq(&container, &c, "qu", "ㄔㄨ");
  checkEq(&container, &c, "qu7", "ㄔㄨˊ");
  checkEq(&container, &c, "qu8", "ㄔㄨˇ");
  checkEq(&container, &c, "qu9", "ㄔㄨˋ");
  checkEq(&container, &c, "qua", "ㄔㄨㄚ");
  checkEq(&container, &c, "qua8", "ㄔㄨㄚˇ");
  checkEq(&container, &c, "qua9", "ㄔㄨㄚˋ");
  checkEq(&container, &c, "quo", "ㄔㄨㄛ");
  checkEq(&container, &c, "quo9", "ㄔㄨㄛˋ");
  checkEq(&container, &c, "quy", "ㄔㄨㄞ");
  checkEq(&container, &c, "quy7", "ㄔㄨㄞˊ");
  checkEq(&container, &c, "quy8", "ㄔㄨㄞˇ");
  checkEq(&container, &c, "quy9", "ㄔㄨㄞˋ");
  checkEq(&container, &c, "qut", "ㄔㄨㄟ");
  checkEq(&container, &c, "qut7", "ㄔㄨㄟˊ");
  checkEq(&container, &c, "qut8", "ㄔㄨㄟˇ");
  checkEq(&container, &c, "qut9", "ㄔㄨㄟˋ");
  checkEq(&container, &c, "qum", "ㄔㄨㄢ");
  checkEq(&container, &c, "qum7", "ㄔㄨㄢˊ");
  checkEq(&container, &c, "qum8", "ㄔㄨㄢˇ");
  checkEq(&container, &c, "qum9", "ㄔㄨㄢˋ");
  checkEq(&container, &c, "qun", "ㄔㄨㄣ");
  checkEq(&container, &c, "qun7", "ㄔㄨㄣˊ");
  checkEq(&container, &c, "qun8", "ㄔㄨㄣˇ");
  checkEq(&container, &c, "quk", "ㄔㄨㄤ");
  checkEq(&container, &c, "quk7", "ㄔㄨㄤˊ");
  checkEq(&container, &c, "quk8", "ㄔㄨㄤˇ");
  checkEq(&container, &c, "quk9", "ㄔㄨㄤˋ");
  checkEq(&container, &c, "qug", "ㄔㄨㄥ");
  checkEq(&container, &c, "qug7", "ㄔㄨㄥˊ");
  checkEq(&container, &c, "qug8", "ㄔㄨㄥˇ");
  checkEq(&container, &c, "qug9", "ㄔㄨㄥˋ");
  checkEq(&container, &c, "x", "ㄕ");
  checkEq(&container, &c, "x7", "ㄕˊ");
  checkEq(&container, &c, "x8", "ㄕˇ");
  checkEq(&container, &c, "x9", "ㄕˋ");
  checkEq(&container, &c, "x0", "ㄕ˙");
  checkEq(&container, &c, "xa", "ㄕㄚ");
  checkEq(&container, &c, "xa7", "ㄕㄚˊ");
  checkEq(&container, &c, "xa8", "ㄕㄚˇ");
  checkEq(&container, &c, "xa9", "ㄕㄚˋ");
  checkEq(&container, &c, "xa0", "ㄕㄚ˙");
  checkEq(&container, &c, "xe", "ㄕㄜ");
  checkEq(&container, &c, "xe7", "ㄕㄜˊ");
  checkEq(&container, &c, "xe8", "ㄕㄜˇ");
  checkEq(&container, &c, "xe9", "ㄕㄜˋ");
  checkEq(&container, &c, "xy", "ㄕㄞ");
  checkEq(&container, &c, "xy8", "ㄕㄞˇ");
  checkEq(&container, &c, "xy9", "ㄕㄞˋ");
  checkEq(&container, &c, "xt7", "ㄕㄟˊ");
  checkEq(&container, &c, "xf", "ㄕㄠ");
  checkEq(&container, &c, "xf7", "ㄕㄠˊ");
  checkEq(&container, &c, "xf8", "ㄕㄠˇ");
  checkEq(&container, &c, "xf9", "ㄕㄠˋ");
  checkEq(&container, &c, "xw", "ㄕㄡ");
  checkEq(&container, &c, "xw7", "ㄕㄡˊ");
  checkEq(&container, &c, "xw8", "ㄕㄡˇ");
  checkEq(&container, &c, "xw9", "ㄕㄡˋ");
  checkEq(&container, &c, "xm", "ㄕㄢ");
  checkEq(&container, &c, "xm7", "ㄕㄢˊ");
  checkEq(&container, &c, "xm8", "ㄕㄢˇ");
  checkEq(&container, &c, "xm9", "ㄕㄢˋ");
  checkEq(&container, &c, "xn", "ㄕㄣ");
  checkEq(&container, &c, "xn7", "ㄕㄣˊ");
  checkEq(&container, &c, "xn8", "ㄕㄣˇ");
  checkEq(&container, &c, "xn9", "ㄕㄣˋ");
  checkEq(&container, &c, "xk", "ㄕㄤ");
  checkEq(&container, &c, "xk8", "ㄕㄤˇ");
  checkEq(&container, &c, "xk9", "ㄕㄤˋ");
  checkEq(&container, &c, "xk0", "ㄕㄤ˙");
  checkEq(&container, &c, "xg", "ㄕㄥ");
  checkEq(&container, &c, "xg7", "ㄕㄥˊ");
  checkEq(&container, &c, "xg8", "ㄕㄥˇ");
  checkEq(&container, &c, "xg9", "ㄕㄥˋ");
  checkEq(&container, &c, "xu", "ㄕㄨ");
  checkEq(&container, &c, "xu7", "ㄕㄨˊ");
  checkEq(&container, &c, "xu8", "ㄕㄨˇ");
  checkEq(&container, &c, "xu9", "ㄕㄨˋ");
  checkEq(&container, &c, "xua", "ㄕㄨㄚ");
  checkEq(&container, &c, "xua8", "ㄕㄨㄚˇ");
  checkEq(&container, &c, "xua9", "ㄕㄨㄚˋ");
  checkEq(&container, &c, "xuo", "ㄕㄨㄛ");
  checkEq(&container, &c, "xuo9", "ㄕㄨㄛˋ");
  checkEq(&container, &c, "xuy", "ㄕㄨㄞ");
  checkEq(&container, &c, "xuy8", "ㄕㄨㄞˇ");
  checkEq(&container, &c, "xuy9", "ㄕㄨㄞˋ");
  checkEq(&container, &c, "xut", "ㄕㄨㄟ");
  checkEq(&container, &c, "xut7", "ㄕㄨㄟˊ");
  checkEq(&container, &c, "xut8", "ㄕㄨㄟˇ");
  checkEq(&container, &c, "xut9", "ㄕㄨㄟˋ");
  checkEq(&container, &c, "xum", "ㄕㄨㄢ");
  checkEq(&container, &c, "xum9", "ㄕㄨㄢˋ");
  checkEq(&container, &c, "xun8", "ㄕㄨㄣˇ");
  checkEq(&container, &c, "xun9", "ㄕㄨㄣˋ");
  checkEq(&container, &c, "xuk", "ㄕㄨㄤ");
  checkEq(&container, &c, "xuk7", "ㄕㄨㄤˊ");
  checkEq(&container, &c, "xuk8", "ㄕㄨㄤˇ");
  checkEq(&container, &c, "xuk9", "ㄕㄨㄤˋ");
  checkEq(&container, &c, "r9", "ㄖˋ");
  checkEq(&container, &c, "re8", "ㄖㄜˇ");
  checkEq(&container, &c, "re9", "ㄖㄜˋ");
  checkEq(&container, &c, "rf7", "ㄖㄠˊ");
  checkEq(&container, &c, "rf8", "ㄖㄠˇ");
  checkEq(&container, &c, "rf9", "ㄖㄠˋ");
  checkEq(&container, &c, "rw7", "ㄖㄡˊ");
  checkEq(&container, &c, "rw8", "ㄖㄡˇ");
  checkEq(&container, &c, "rw9", "ㄖㄡˋ");
  checkEq(&container, &c, "rm7", "ㄖㄢˊ");
  checkEq(&container, &c, "rm8", "ㄖㄢˇ");
  checkEq(&container, &c, "rm9", "ㄖㄢˋ");
  checkEq(&container, &c, "rn7", "ㄖㄣˊ");
  checkEq(&container, &c, "rn8", "ㄖㄣˇ");
  checkEq(&container, &c, "rn9", "ㄖㄣˋ");
  checkEq(&container, &c, "rk", "ㄖㄤ");
  checkEq(&container, &c, "rk7", "ㄖㄤˊ");
  checkEq(&container, &c, "rk8", "ㄖㄤˇ");
  checkEq(&container, &c, "rk9", "ㄖㄤˋ");
  checkEq(&container, &c, "rg", "ㄖㄥ");
  checkEq(&container, &c, "rg7", "ㄖㄥˊ");
  checkEq(&container, &c, "rg8", "ㄖㄥˇ");
  checkEq(&container, &c, "rg9", "ㄖㄥˋ");
  checkEq(&container, &c, "ru7", "ㄖㄨˊ");
  checkEq(&container, &c, "ru8", "ㄖㄨˇ");
  checkEq(&container, &c, "ru9", "ㄖㄨˋ");
  checkEq(&container, &c, "ruo7", "ㄖㄨㄛˊ");
  checkEq(&container, &c, "ruo9", "ㄖㄨㄛˋ");
  checkEq(&container, &c, "rut7", "ㄖㄨㄟˊ");
  checkEq(&container, &c, "rut8", "ㄖㄨㄟˇ");
  checkEq(&container, &c, "rut9", "ㄖㄨㄟˋ");
  checkEq(&container, &c, "rum7", "ㄖㄨㄢˊ");
  checkEq(&container, &c, "rum8", "ㄖㄨㄢˇ");
  checkEq(&container, &c, "rum9", "ㄖㄨㄢˋ");
  checkEq(&container, &c, "run7", "ㄖㄨㄣˊ");
  checkEq(&container, &c, "run8", "ㄖㄨㄣˇ");
  checkEq(&container, &c, "run9", "ㄖㄨㄣˋ");
  checkEq(&container, &c, "rug7", "ㄖㄨㄥˊ");
  checkEq(&container, &c, "rug8", "ㄖㄨㄥˇ");
  checkEq(&container, &c, "rug9", "ㄖㄨㄥˋ");
  checkEq(&container, &c, "z", "ㄗ");
  checkEq(&container, &c, "z7", "ㄗˊ");
  checkEq(&container, &c, "z8", "ㄗˇ");
  checkEq(&container, &c, "z9", "ㄗˋ");
  checkEq(&container, &c, "z0", "ㄗ˙");
  checkEq(&container, &c, "za", "ㄗㄚ");
  checkEq(&container, &c, "za7", "ㄗㄚˊ");
  checkEq(&container, &c, "za8", "ㄗㄚˇ");
  checkEq(&container, &c, "ze7", "ㄗㄜˊ");
  checkEq(&container, &c, "ze8", "ㄗㄜˇ");
  checkEq(&container, &c, "ze9", "ㄗㄜˋ");
  checkEq(&container, &c, "zy", "ㄗㄞ");
  checkEq(&container, &c, "zy8", "ㄗㄞˇ");
  checkEq(&container, &c, "zy9", "ㄗㄞˋ");
  checkEq(&container, &c, "zt7", "ㄗㄟˊ");
  checkEq(&container, &c, "zf", "ㄗㄠ");
  checkEq(&container, &c, "zf7", "ㄗㄠˊ");
  checkEq(&container, &c, "zf8", "ㄗㄠˇ");
  checkEq(&container, &c, "zf9", "ㄗㄠˋ");
  checkEq(&container, &c, "zw", "ㄗㄡ");
  checkEq(&container, &c, "zw8", "ㄗㄡˇ");
  checkEq(&container, &c, "zw9", "ㄗㄡˋ");
  checkEq(&container, &c, "zm", "ㄗㄢ");
  checkEq(&container, &c, "zm7", "ㄗㄢˊ");
  checkEq(&container, &c, "zm8", "ㄗㄢˇ");
  checkEq(&container, &c, "zm9", "ㄗㄢˋ");
  checkEq(&container, &c, "zn", "ㄗㄣ");
  checkEq(&container, &c, "zn8", "ㄗㄣˇ");
  checkEq(&container, &c, "zn9", "ㄗㄣˋ");
  checkEq(&container, &c, "zk", "ㄗㄤ");
  checkEq(&container, &c, "zk8", "ㄗㄤˇ");
  checkEq(&container, &c, "zk9", "ㄗㄤˋ");
  checkEq(&container, &c, "zg", "ㄗㄥ");
  checkEq(&container, &c, "zg8", "ㄗㄥˇ");
  checkEq(&container, &c, "zg9", "ㄗㄥˋ");
  checkEq(&container, &c, "zu", "ㄗㄨ");
  checkEq(&container, &c, "zu7", "ㄗㄨˊ");
  checkEq(&container, &c, "zu8", "ㄗㄨˇ");
  checkEq(&container, &c, "zu9", "ㄗㄨˋ");
  checkEq(&container, &c, "zuo", "ㄗㄨㄛ");
  checkEq(&container, &c, "zuo7", "ㄗㄨㄛˊ");
  checkEq(&container, &c, "zuo8", "ㄗㄨㄛˇ");
  checkEq(&container, &c, "zuo9", "ㄗㄨㄛˋ");
  checkEq(&container, &c, "zuo0", "ㄗㄨㄛ˙");
  checkEq(&container, &c, "zut", "ㄗㄨㄟ");
  checkEq(&container, &c, "zut8", "ㄗㄨㄟˇ");
  checkEq(&container, &c, "zut9", "ㄗㄨㄟˋ");
  checkEq(&container, &c, "zum", "ㄗㄨㄢ");
  checkEq(&container, &c, "zum8", "ㄗㄨㄢˇ");
  checkEq(&container, &c, "zum9", "ㄗㄨㄢˋ");
  checkEq(&container, &c, "zun", "ㄗㄨㄣ");
  checkEq(&container, &c, "zun8", "ㄗㄨㄣˇ");
  checkEq(&container, &c, "zun9", "ㄗㄨㄣˋ");
  checkEq(&container, &c, "zug", "ㄗㄨㄥ");
  checkEq(&container, &c, "zug8", "ㄗㄨㄥˇ");
  checkEq(&container, &c, "zug9", "ㄗㄨㄥˋ");
  checkEq(&container, &c, "c", "ㄘ");
  checkEq(&container, &c, "c7", "ㄘˊ");
  checkEq(&container, &c, "c8", "ㄘˇ");
  checkEq(&container, &c, "c9", "ㄘˋ");
  checkEq(&container, &c, "ca", "ㄘㄚ");
  checkEq(&container, &c, "ca8", "ㄘㄚˇ");
  checkEq(&container, &c, "ca9", "ㄘㄚˋ");
  checkEq(&container, &c, "ce9", "ㄘㄜˋ");
  checkEq(&container, &c, "cy", "ㄘㄞ");
  checkEq(&container, &c, "cy7", "ㄘㄞˊ");
  checkEq(&container, &c, "cy8", "ㄘㄞˇ");
  checkEq(&container, &c, "cy9", "ㄘㄞˋ");
  checkEq(&container, &c, "cf", "ㄘㄠ");
  checkEq(&container, &c, "cf7", "ㄘㄠˊ");
  checkEq(&container, &c, "cf8", "ㄘㄠˇ");
  checkEq(&container, &c, "cf9", "ㄘㄠˋ");
  checkEq(&container, &c, "cw", "ㄘㄡ");
  checkEq(&container, &c, "cw7", "ㄘㄡˊ");
  checkEq(&container, &c, "cw8", "ㄘㄡˇ");
  checkEq(&container, &c, "cw9", "ㄘㄡˋ");
  checkEq(&container, &c, "cm", "ㄘㄢ");
  checkEq(&container, &c, "cm7", "ㄘㄢˊ");
  checkEq(&container, &c, "cm8", "ㄘㄢˇ");
  checkEq(&container, &c, "cm9", "ㄘㄢˋ");
  checkEq(&container, &c, "cn", "ㄘㄣ");
  checkEq(&container, &c, "cn7", "ㄘㄣˊ");
  checkEq(&container, &c, "ck", "ㄘㄤ");
  checkEq(&container, &c, "ck7", "ㄘㄤˊ");
  checkEq(&container, &c, "ck8", "ㄘㄤˇ");
  checkEq(&container, &c, "ck9", "ㄘㄤˋ");
  checkEq(&container, &c, "cg", "ㄘㄥ");
  checkEq(&container, &c, "cg7", "ㄘㄥˊ");
  checkEq(&container, &c, "cg8", "ㄘㄥˇ");
  checkEq(&container, &c, "cg9", "ㄘㄥˋ");
  checkEq(&container, &c, "cu", "ㄘㄨ");
  checkEq(&container, &c, "cu7", "ㄘㄨˊ");
  checkEq(&container, &c, "cu8", "ㄘㄨˇ");
  checkEq(&container, &c, "cu9", "ㄘㄨˋ");
  checkEq(&container, &c, "cuo", "ㄘㄨㄛ");
  checkEq(&container, &c, "cuo7", "ㄘㄨㄛˊ");
  checkEq(&container, &c, "cuo8", "ㄘㄨㄛˇ");
  checkEq(&container, &c, "cuo9", "ㄘㄨㄛˋ");
  checkEq(&container, &c, "cut", "ㄘㄨㄟ");
  checkEq(&container, &c, "cut8", "ㄘㄨㄟˇ");
  checkEq(&container, &c, "cut9", "ㄘㄨㄟˋ");
  checkEq(&container, &c, "cum", "ㄘㄨㄢ");
  checkEq(&container, &c, "cum7", "ㄘㄨㄢˊ");
  checkEq(&container, &c, "cum8", "ㄘㄨㄢˇ");
  checkEq(&container, &c, "cum9", "ㄘㄨㄢˋ");
  checkEq(&container, &c, "cun", "ㄘㄨㄣ");
  checkEq(&container, &c, "cun7", "ㄘㄨㄣˊ");
  checkEq(&container, &c, "cun8", "ㄘㄨㄣˇ");
  checkEq(&container, &c, "cun9", "ㄘㄨㄣˋ");
  checkEq(&container, &c, "cug", "ㄘㄨㄥ");
  checkEq(&container, &c, "cug7", "ㄘㄨㄥˊ");
  checkEq(&container, &c, "cug8", "ㄘㄨㄥˇ");
  checkEq(&container, &c, "cug9", "ㄘㄨㄥˋ");
  checkEq(&container, &c, "s", "ㄙ");
  checkEq(&container, &c, "s8", "ㄙˇ");
  checkEq(&container, &c, "s9", "ㄙˋ");
  checkEq(&container, &c, "sa", "ㄙㄚ");
  checkEq(&container, &c, "sa8", "ㄙㄚˇ");
  checkEq(&container, &c, "sa9", "ㄙㄚˋ");
  checkEq(&container, &c, "sa0", "ㄙㄚ˙");
  checkEq(&container, &c, "se", "ㄙㄜ");
  checkEq(&container, &c, "se9", "ㄙㄜˋ");
  checkEq(&container, &c, "sy", "ㄙㄞ");
  checkEq(&container, &c, "sy7", "ㄙㄞˊ");
  checkEq(&container, &c, "sy8", "ㄙㄞˇ");
  checkEq(&container, &c, "sy9", "ㄙㄞˋ");
  checkEq(&container, &c, "st", "ㄙㄟ");
  checkEq(&container, &c, "sf", "ㄙㄠ");
  checkEq(&container, &c, "sf8", "ㄙㄠˇ");
  checkEq(&container, &c, "sf9", "ㄙㄠˋ");
  checkEq(&container, &c, "sw", "ㄙㄡ");
  checkEq(&container, &c, "sw8", "ㄙㄡˇ");
  checkEq(&container, &c, "sw9", "ㄙㄡˋ");
  checkEq(&container, &c, "sm", "ㄙㄢ");
  checkEq(&container, &c, "sm8", "ㄙㄢˇ");
  checkEq(&container, &c, "sm9", "ㄙㄢˋ");
  checkEq(&container, &c, "sn", "ㄙㄣ");
  checkEq(&container, &c, "sn8", "ㄙㄣˇ");
  checkEq(&container, &c, "sk", "ㄙㄤ");
  checkEq(&container, &c, "sk8", "ㄙㄤˇ");
  checkEq(&container, &c, "sk9", "ㄙㄤˋ");
  checkEq(&container, &c, "sg", "ㄙㄥ");
  checkEq(&container, &c, "sg9", "ㄙㄥˋ");
  checkEq(&container, &c, "su", "ㄙㄨ");
  checkEq(&container, &c, "su7", "ㄙㄨˊ");
  checkEq(&container, &c, "su8", "ㄙㄨˇ");
  checkEq(&container, &c, "su9", "ㄙㄨˋ");
  checkEq(&container, &c, "suo", "ㄙㄨㄛ");
  checkEq(&container, &c, "suo7", "ㄙㄨㄛˊ");
  checkEq(&container, &c, "suo8", "ㄙㄨㄛˇ");
  checkEq(&container, &c, "suo9", "ㄙㄨㄛˋ");
  checkEq(&container, &c, "sut", "ㄙㄨㄟ");
  checkEq(&container, &c, "sut7", "ㄙㄨㄟˊ");
  checkEq(&container, &c, "sut8", "ㄙㄨㄟˇ");
  checkEq(&container, &c, "sut9", "ㄙㄨㄟˋ");
  checkEq(&container, &c, "sum", "ㄙㄨㄢ");
  checkEq(&container, &c, "sum8", "ㄙㄨㄢˇ");
  checkEq(&container, &c, "sum9", "ㄙㄨㄢˋ");
  checkEq(&container, &c, "sun", "ㄙㄨㄣ");
  checkEq(&container, &c, "sun8", "ㄙㄨㄣˇ");
  checkEq(&container, &c, "sun9", "ㄙㄨㄣˋ");
  checkEq(&container, &c, "sug", "ㄙㄨㄥ");
  checkEq(&container, &c, "sug7", "ㄙㄨㄥˊ");
  checkEq(&container, &c, "sug8", "ㄙㄨㄥˇ");
  checkEq(&container, &c, "sug9", "ㄙㄨㄥˋ");
  checkEq(&container, &c, "a", "ㄚ");
  checkEq(&container, &c, "a7", "ㄚˊ");
  checkEq(&container, &c, "a9", "ㄚˋ");
  checkEq(&container, &c, "a0", "ㄚ˙");
  checkEq(&container, &c, "o", "ㄛ");
  checkEq(&container, &c, "o7", "ㄛˊ");
  checkEq(&container, &c, "o8", "ㄛˇ");
  checkEq(&container, &c, "o9", "ㄛˋ");
  checkEq(&container, &c, "e", "ㄜ");
  checkEq(&container, &c, "e7", "ㄜˊ");
  checkEq(&container, &c, "e8", "ㄜˇ");
  checkEq(&container, &c, "e9", "ㄜˋ");
  // checkEq(&container, &c, "e7", "ㄝˊ");
  // checkEq(&container, &c, "e8", "ㄝˇ");
  // checkEq(&container, &c, "e9", "ㄝˋ");
  // checkEq(&container, &c, "e0", "ㄝ˙");
  checkEq(&container, &c, "y", "ㄞ");
  checkEq(&container, &c, "y7", "ㄞˊ");
  checkEq(&container, &c, "y8", "ㄞˇ");
  checkEq(&container, &c, "y9", "ㄞˋ");
  checkEq(&container, &c, "t9", "ㄟˋ");
  checkEq(&container, &c, "f ", "ㄠ ");
  checkEq(&container, &c, "f7", "ㄠˊ");
  checkEq(&container, &c, "f8", "ㄠˇ");
  checkEq(&container, &c, "f9", "ㄠˋ");
  checkEq(&container, &c, "w", "ㄡ");
  checkEq(&container, &c, "w7", "ㄡˊ");
  checkEq(&container, &c, "w8", "ㄡˇ");
  checkEq(&container, &c, "w9", "ㄡˋ");
  checkEq(&container, &c, "w0", "ㄡ˙");
  checkEq(&container, &c, "m ", "ㄢ ");
  checkEq(&container, &c, "m7", "ㄢˊ");
  checkEq(&container, &c, "m8", "ㄢˇ");
  checkEq(&container, &c, "m9", "ㄢˋ");
  checkEq(&container, &c, "n ", "ㄣ ");
  checkEq(&container, &c, "n7", "ㄣˊ");
  checkEq(&container, &c, "n8", "ㄣˇ");
  checkEq(&container, &c, "n9", "ㄣˋ");
  checkEq(&container, &c, "n0", "ㄣ˙");
  checkEq(&container, &c, "k ", "ㄤ ");
  checkEq(&container, &c, "k7", "ㄤˊ");
  checkEq(&container, &c, "k8", "ㄤˇ");
  checkEq(&container, &c, "k9", "ㄤˋ");
  checkEq(&container, &c, "g ", "ㄥ ");
  checkEq(&container, &c, "g9", "ㄥˋ");
  checkEq(&container, &c, "l ", "ㄦ ");
  checkEq(&container, &c, "l7", "ㄦˊ");
  checkEq(&container, &c, "l8", "ㄦˇ");
  checkEq(&container, &c, "l9", "ㄦˋ");
  checkEq(&container, &c, "l0", "ㄦ˙");
  checkEq(&container, &c, "i", "ㄧ");
  checkEq(&container, &c, "i7", "ㄧˊ");
  checkEq(&container, &c, "i8", "ㄧˇ");
  checkEq(&container, &c, "i9", "ㄧˋ");
  checkEq(&container, &c, "ia", "ㄧㄚ");
  checkEq(&container, &c, "ia7", "ㄧㄚˊ");
  checkEq(&container, &c, "ia8", "ㄧㄚˇ");
  checkEq(&container, &c, "ia9", "ㄧㄚˋ");
  checkEq(&container, &c, "ia0", "ㄧㄚ˙");
  checkEq(&container, &c, "io", "ㄧㄛ");
  checkEq(&container, &c, "io0", "ㄧㄛ˙");
  checkEq(&container, &c, "ie", "ㄧㄝ");
  checkEq(&container, &c, "ie7", "ㄧㄝˊ");
  checkEq(&container, &c, "ie8", "ㄧㄝˇ");
  checkEq(&container, &c, "ie9", "ㄧㄝˋ");
  checkEq(&container, &c, "ie0", "ㄧㄝ˙");
  checkEq(&container, &c, "iy7", "ㄧㄞˊ");
  checkEq(&container, &c, "if", "ㄧㄠ");
  checkEq(&container, &c, "if7", "ㄧㄠˊ");
  checkEq(&container, &c, "if8", "ㄧㄠˇ");
  checkEq(&container, &c, "if9", "ㄧㄠˋ");
  checkEq(&container, &c, "iw", "ㄧㄡ");
  checkEq(&container, &c, "iw7", "ㄧㄡˊ");
  checkEq(&container, &c, "iw8", "ㄧㄡˇ");
  checkEq(&container, &c, "iw9", "ㄧㄡˋ");
  checkEq(&container, &c, "im", "ㄧㄢ");
  checkEq(&container, &c, "im7", "ㄧㄢˊ");
  checkEq(&container, &c, "im8", "ㄧㄢˇ");
  checkEq(&container, &c, "im9", "ㄧㄢˋ");
  checkEq(&container, &c, "in", "ㄧㄣ");
  checkEq(&container, &c, "in7", "ㄧㄣˊ");
  checkEq(&container, &c, "in8", "ㄧㄣˇ");
  checkEq(&container, &c, "in9", "ㄧㄣˋ");
  checkEq(&container, &c, "ik", "ㄧㄤ");
  checkEq(&container, &c, "ik7", "ㄧㄤˊ");
  checkEq(&container, &c, "ik8", "ㄧㄤˇ");
  checkEq(&container, &c, "ik9", "ㄧㄤˋ");
  checkEq(&container, &c, "ig", "ㄧㄥ");
  checkEq(&container, &c, "ig7", "ㄧㄥˊ");
  checkEq(&container, &c, "ig8", "ㄧㄥˇ");
  checkEq(&container, &c, "ig9", "ㄧㄥˋ");
  checkEq(&container, &c, "u", "ㄨ");
  checkEq(&container, &c, "u7", "ㄨˊ");
  checkEq(&container, &c, "u8", "ㄨˇ");
  checkEq(&container, &c, "u9", "ㄨˋ");
  checkEq(&container, &c, "ua", "ㄨㄚ");
  checkEq(&container, &c, "ua7", "ㄨㄚˊ");
  checkEq(&container, &c, "ua8", "ㄨㄚˇ");
  checkEq(&container, &c, "ua9", "ㄨㄚˋ");
  checkEq(&container, &c, "ua0", "ㄨㄚ˙");
  checkEq(&container, &c, "uo", "ㄨㄛ");
  checkEq(&container, &c, "uo8", "ㄨㄛˇ");
  checkEq(&container, &c, "uo9", "ㄨㄛˋ");
  checkEq(&container, &c, "uy", "ㄨㄞ");
  checkEq(&container, &c, "uy8", "ㄨㄞˇ");
  checkEq(&container, &c, "uy9", "ㄨㄞˋ");
  checkEq(&container, &c, "ut", "ㄨㄟ");
  checkEq(&container, &c, "ut7", "ㄨㄟˊ");
  checkEq(&container, &c, "ut8", "ㄨㄟˇ");
  checkEq(&container, &c, "ut9", "ㄨㄟˋ");
  checkEq(&container, &c, "um", "ㄨㄢ");
  checkEq(&container, &c, "um7", "ㄨㄢˊ");
  checkEq(&container, &c, "um8", "ㄨㄢˇ");
  checkEq(&container, &c, "um9", "ㄨㄢˋ");
  checkEq(&container, &c, "un", "ㄨㄣ");
  checkEq(&container, &c, "un7", "ㄨㄣˊ");
  checkEq(&container, &c, "un8", "ㄨㄣˇ");
  checkEq(&container, &c, "un9", "ㄨㄣˋ");
  checkEq(&container, &c, "uk", "ㄨㄤ");
  checkEq(&container, &c, "uk7", "ㄨㄤˊ");
  checkEq(&container, &c, "uk8", "ㄨㄤˇ");
  checkEq(&container, &c, "uk9", "ㄨㄤˋ");
  checkEq(&container, &c, "ug", "ㄨㄥ");
  checkEq(&container, &c, "ug8", "ㄨㄥˇ");
  checkEq(&container, &c, "ug9", "ㄨㄥˋ");
  checkEq(&container, &c, "v", "ㄩ");
  checkEq(&container, &c, "v7", "ㄩˊ");
  checkEq(&container, &c, "v8", "ㄩˇ");
  checkEq(&container, &c, "v9", "ㄩˋ");
  checkEq(&container, &c, "ve", "ㄩㄝ");
  checkEq(&container, &c, "ve8", "ㄩㄝˇ");
  checkEq(&container, &c, "ve9", "ㄩㄝˋ");
  checkEq(&container, &c, "vm", "ㄩㄢ");
  checkEq(&container, &c, "vm7", "ㄩㄢˊ");
  checkEq(&container, &c, "vm8", "ㄩㄢˇ");
  checkEq(&container, &c, "vm9", "ㄩㄢˋ");
  checkEq(&container, &c, "vn", "ㄩㄣ");
  checkEq(&container, &c, "vn7", "ㄩㄣˊ");
  checkEq(&container, &c, "vn8", "ㄩㄣˇ");
  checkEq(&container, &c, "vn9", "ㄩㄣˋ");
  checkEq(&container, &c, "vg", "ㄩㄥ");
  checkEq(&container, &c, "vg7", "ㄩㄥˊ");
  checkEq(&container, &c, "vg8", "ㄩㄥˇ");
  checkEq(&container, &c, "vg9", "ㄩㄥˋ");
  ASSERT_TRUE(container.empty());
}

TEST(TekkonTests_Advanced, AlvinLiuKeys) {
  // Testing handleAlvinLiu()
  Composer c = Composer("", ofAlvinLiu);
  std::vector<std::string> container = {};
  checkEq(&container, &c, "kig", "ㄎㄧㄤ");
  checkEq(&container, &c, "giwf", "ㄍㄧㄠˊ");
  checkEq(&container, &c, "gin", "ㄍㄧㄣ");
  checkEq(&container, &c, "kig", "ㄎㄧㄤ");
  checkEq(&container, &c, "giwf", "ㄍㄧㄠˊ");
  checkEq(&container, &c, "gin", "ㄍㄧㄣ");
  checkEq(&container, &c, "bigf", "ㄅㄧㄤˊ");
  checkEq(&container, &c, "bigl", "ㄅㄧㄤˋ");
  checkEq(&container, &c, "dug", "ㄉㄨㄤ");
  checkEq(&container, &c, "ba", "ㄅㄚ");
  checkEq(&container, &c, "baf", "ㄅㄚˊ");
  checkEq(&container, &c, "baj", "ㄅㄚˇ");
  checkEq(&container, &c, "bal", "ㄅㄚˋ");
  checkEq(&container, &c, "bad", "ㄅㄚ˙");
  checkEq(&container, &c, "bo", "ㄅㄛ");
  checkEq(&container, &c, "bof", "ㄅㄛˊ");
  checkEq(&container, &c, "boj", "ㄅㄛˇ");
  checkEq(&container, &c, "bol", "ㄅㄛˋ");
  checkEq(&container, &c, "bod", "ㄅㄛ˙");
  checkEq(&container, &c, "bh", "ㄅㄞ");
  checkEq(&container, &c, "bhf", "ㄅㄞˊ");
  checkEq(&container, &c, "bhj", "ㄅㄞˇ");
  checkEq(&container, &c, "bhl", "ㄅㄞˋ");
  checkEq(&container, &c, "bhd", "ㄅㄞ˙");
  checkEq(&container, &c, "bk", "ㄅㄟ");
  checkEq(&container, &c, "bkj", "ㄅㄟˇ");
  checkEq(&container, &c, "bkl", "ㄅㄟˋ");
  checkEq(&container, &c, "bkd", "ㄅㄟ˙");
  checkEq(&container, &c, "bw", "ㄅㄠ");
  checkEq(&container, &c, "bwf", "ㄅㄠˊ");
  checkEq(&container, &c, "bwj", "ㄅㄠˇ");
  checkEq(&container, &c, "bwl", "ㄅㄠˋ");
  checkEq(&container, &c, "bb", "ㄅㄢ");
  checkEq(&container, &c, "bbj", "ㄅㄢˇ");
  checkEq(&container, &c, "bbl", "ㄅㄢˋ");
  checkEq(&container, &c, "bn", "ㄅㄣ");
  checkEq(&container, &c, "bnj", "ㄅㄣˇ");
  checkEq(&container, &c, "bnl", "ㄅㄣˋ");
  checkEq(&container, &c, "bg", "ㄅㄤ");
  checkEq(&container, &c, "bgj", "ㄅㄤˇ");
  checkEq(&container, &c, "bgl", "ㄅㄤˋ");
  checkEq(&container, &c, "bm", "ㄅㄥ");
  checkEq(&container, &c, "bmf", "ㄅㄥˊ");
  checkEq(&container, &c, "bmj", "ㄅㄥˇ");
  checkEq(&container, &c, "bml", "ㄅㄥˋ");
  checkEq(&container, &c, "bi", "ㄅㄧ");
  checkEq(&container, &c, "bif", "ㄅㄧˊ");
  checkEq(&container, &c, "bij", "ㄅㄧˇ");
  checkEq(&container, &c, "bil", "ㄅㄧˋ");
  checkEq(&container, &c, "bie", "ㄅㄧㄝ");
  checkEq(&container, &c, "bief", "ㄅㄧㄝˊ");
  checkEq(&container, &c, "biej", "ㄅㄧㄝˇ");
  checkEq(&container, &c, "biel", "ㄅㄧㄝˋ");
  checkEq(&container, &c, "biw", "ㄅㄧㄠ");
  checkEq(&container, &c, "biwj", "ㄅㄧㄠˇ");
  checkEq(&container, &c, "biwl", "ㄅㄧㄠˋ");
  checkEq(&container, &c, "bib", "ㄅㄧㄢ");
  checkEq(&container, &c, "bibf", "ㄅㄧㄢˊ");
  checkEq(&container, &c, "bibj", "ㄅㄧㄢˇ");
  checkEq(&container, &c, "bibl", "ㄅㄧㄢˋ");
  checkEq(&container, &c, "bin", "ㄅㄧㄣ");
  checkEq(&container, &c, "binj", "ㄅㄧㄣˇ");
  checkEq(&container, &c, "binl", "ㄅㄧㄣˋ");
  checkEq(&container, &c, "bim", "ㄅㄧㄥ");
  checkEq(&container, &c, "bimj", "ㄅㄧㄥˇ");
  checkEq(&container, &c, "biml", "ㄅㄧㄥˋ");
  checkEq(&container, &c, "bu", "ㄅㄨ");
  checkEq(&container, &c, "buf", "ㄅㄨˊ");
  checkEq(&container, &c, "buj", "ㄅㄨˇ");
  checkEq(&container, &c, "bul", "ㄅㄨˋ");
  checkEq(&container, &c, "pa", "ㄆㄚ");
  checkEq(&container, &c, "paf", "ㄆㄚˊ");
  checkEq(&container, &c, "paj", "ㄆㄚˇ");
  checkEq(&container, &c, "pal", "ㄆㄚˋ");
  checkEq(&container, &c, "pad", "ㄆㄚ˙");
  checkEq(&container, &c, "po", "ㄆㄛ");
  checkEq(&container, &c, "pof", "ㄆㄛˊ");
  checkEq(&container, &c, "poj", "ㄆㄛˇ");
  checkEq(&container, &c, "pol", "ㄆㄛˋ");
  checkEq(&container, &c, "ph", "ㄆㄞ");
  checkEq(&container, &c, "phf", "ㄆㄞˊ");
  checkEq(&container, &c, "phj", "ㄆㄞˇ");
  checkEq(&container, &c, "phl", "ㄆㄞˋ");
  checkEq(&container, &c, "pk", "ㄆㄟ");
  checkEq(&container, &c, "pkf", "ㄆㄟˊ");
  checkEq(&container, &c, "pkj", "ㄆㄟˇ");
  checkEq(&container, &c, "pkl", "ㄆㄟˋ");
  checkEq(&container, &c, "pw", "ㄆㄠ");
  checkEq(&container, &c, "pwf", "ㄆㄠˊ");
  checkEq(&container, &c, "pwj", "ㄆㄠˇ");
  checkEq(&container, &c, "pwl", "ㄆㄠˋ");
  checkEq(&container, &c, "pv", "ㄆㄡ");
  checkEq(&container, &c, "pvf", "ㄆㄡˊ");
  checkEq(&container, &c, "pvj", "ㄆㄡˇ");
  checkEq(&container, &c, "pvl", "ㄆㄡˋ");
  checkEq(&container, &c, "pb", "ㄆㄢ");
  checkEq(&container, &c, "pbf", "ㄆㄢˊ");
  checkEq(&container, &c, "pbj", "ㄆㄢˇ");
  checkEq(&container, &c, "pbl", "ㄆㄢˋ");
  checkEq(&container, &c, "pn", "ㄆㄣ");
  checkEq(&container, &c, "pnf", "ㄆㄣˊ");
  checkEq(&container, &c, "pnj", "ㄆㄣˇ");
  checkEq(&container, &c, "pnl", "ㄆㄣˋ");
  checkEq(&container, &c, "pg", "ㄆㄤ");
  checkEq(&container, &c, "pgf", "ㄆㄤˊ");
  checkEq(&container, &c, "pgj", "ㄆㄤˇ");
  checkEq(&container, &c, "pgl", "ㄆㄤˋ");
  checkEq(&container, &c, "pm", "ㄆㄥ");
  checkEq(&container, &c, "pmf", "ㄆㄥˊ");
  checkEq(&container, &c, "pmj", "ㄆㄥˇ");
  checkEq(&container, &c, "pml", "ㄆㄥˋ");
  checkEq(&container, &c, "pi", "ㄆㄧ");
  checkEq(&container, &c, "pif", "ㄆㄧˊ");
  checkEq(&container, &c, "pij", "ㄆㄧˇ");
  checkEq(&container, &c, "pil", "ㄆㄧˋ");
  checkEq(&container, &c, "pia", "ㄆㄧㄚ");
  checkEq(&container, &c, "pie", "ㄆㄧㄝ");
  checkEq(&container, &c, "piej", "ㄆㄧㄝˇ");
  checkEq(&container, &c, "piel", "ㄆㄧㄝˋ");
  checkEq(&container, &c, "piw", "ㄆㄧㄠ");
  checkEq(&container, &c, "piwf", "ㄆㄧㄠˊ");
  checkEq(&container, &c, "piwj", "ㄆㄧㄠˇ");
  checkEq(&container, &c, "piwl", "ㄆㄧㄠˋ");
  checkEq(&container, &c, "pib", "ㄆㄧㄢ");
  checkEq(&container, &c, "pibf", "ㄆㄧㄢˊ");
  checkEq(&container, &c, "pibj", "ㄆㄧㄢˇ");
  checkEq(&container, &c, "pibl", "ㄆㄧㄢˋ");
  checkEq(&container, &c, "pin", "ㄆㄧㄣ");
  checkEq(&container, &c, "pinf", "ㄆㄧㄣˊ");
  checkEq(&container, &c, "pinj", "ㄆㄧㄣˇ");
  checkEq(&container, &c, "pinl", "ㄆㄧㄣˋ");
  checkEq(&container, &c, "pim", "ㄆㄧㄥ");
  checkEq(&container, &c, "pimf", "ㄆㄧㄥˊ");
  checkEq(&container, &c, "pimj", "ㄆㄧㄥˇ");
  checkEq(&container, &c, "piml", "ㄆㄧㄥˋ");
  checkEq(&container, &c, "pu", "ㄆㄨ");
  checkEq(&container, &c, "puf", "ㄆㄨˊ");
  checkEq(&container, &c, "puj", "ㄆㄨˇ");
  checkEq(&container, &c, "pul", "ㄆㄨˋ");
  checkEq(&container, &c, "ma", "ㄇㄚ");
  checkEq(&container, &c, "maf", "ㄇㄚˊ");
  checkEq(&container, &c, "maj", "ㄇㄚˇ");
  checkEq(&container, &c, "mal", "ㄇㄚˋ");
  checkEq(&container, &c, "mad", "ㄇㄚ˙");
  checkEq(&container, &c, "mo", "ㄇㄛ");
  checkEq(&container, &c, "mof", "ㄇㄛˊ");
  checkEq(&container, &c, "moj", "ㄇㄛˇ");
  checkEq(&container, &c, "mol", "ㄇㄛˋ");
  checkEq(&container, &c, "mod", "ㄇㄛ˙");
  checkEq(&container, &c, "me", "ㄇㄜ");
  checkEq(&container, &c, "mel", "ㄇㄜˋ");
  checkEq(&container, &c, "med", "ㄇㄜ˙");
  checkEq(&container, &c, "mh", "ㄇㄞ");
  checkEq(&container, &c, "mhf", "ㄇㄞˊ");
  checkEq(&container, &c, "mhj", "ㄇㄞˇ");
  checkEq(&container, &c, "mhl", "ㄇㄞˋ");
  checkEq(&container, &c, "mkf", "ㄇㄟˊ");
  checkEq(&container, &c, "mkj", "ㄇㄟˇ");
  checkEq(&container, &c, "mkl", "ㄇㄟˋ");
  checkEq(&container, &c, "mw", "ㄇㄠ");
  checkEq(&container, &c, "mwf", "ㄇㄠˊ");
  checkEq(&container, &c, "mwj", "ㄇㄠˇ");
  checkEq(&container, &c, "mwl", "ㄇㄠˋ");
  checkEq(&container, &c, "mvf", "ㄇㄡˊ");
  checkEq(&container, &c, "mvj", "ㄇㄡˇ");
  checkEq(&container, &c, "mvl", "ㄇㄡˋ");
  checkEq(&container, &c, "mb", "ㄇㄢ");
  checkEq(&container, &c, "mbf", "ㄇㄢˊ");
  checkEq(&container, &c, "mbj", "ㄇㄢˇ");
  checkEq(&container, &c, "mbl", "ㄇㄢˋ");
  checkEq(&container, &c, "mn", "ㄇㄣ");
  checkEq(&container, &c, "mnf", "ㄇㄣˊ");
  checkEq(&container, &c, "mnj", "ㄇㄣˇ");
  checkEq(&container, &c, "mnl", "ㄇㄣˋ");
  checkEq(&container, &c, "mnd", "ㄇㄣ˙");
  checkEq(&container, &c, "mg", "ㄇㄤ");
  checkEq(&container, &c, "mgf", "ㄇㄤˊ");
  checkEq(&container, &c, "mgj", "ㄇㄤˇ");
  checkEq(&container, &c, "mgl", "ㄇㄤˋ");
  checkEq(&container, &c, "mm", "ㄇㄥ");
  checkEq(&container, &c, "mmf", "ㄇㄥˊ");
  checkEq(&container, &c, "mmj", "ㄇㄥˇ");
  checkEq(&container, &c, "mml", "ㄇㄥˋ");
  checkEq(&container, &c, "mi", "ㄇㄧ");
  checkEq(&container, &c, "mif", "ㄇㄧˊ");
  checkEq(&container, &c, "mij", "ㄇㄧˇ");
  checkEq(&container, &c, "mil", "ㄇㄧˋ");
  checkEq(&container, &c, "mie", "ㄇㄧㄝ");
  checkEq(&container, &c, "mief", "ㄇㄧㄝˊ");
  checkEq(&container, &c, "miel", "ㄇㄧㄝˋ");
  checkEq(&container, &c, "miw", "ㄇㄧㄠ");
  checkEq(&container, &c, "miwf", "ㄇㄧㄠˊ");
  checkEq(&container, &c, "miwj", "ㄇㄧㄠˇ");
  checkEq(&container, &c, "miwl", "ㄇㄧㄠˋ");
  checkEq(&container, &c, "mivf", "ㄇㄧㄡˊ");
  checkEq(&container, &c, "mivj", "ㄇㄧㄡˇ");
  checkEq(&container, &c, "mivl", "ㄇㄧㄡˋ");
  checkEq(&container, &c, "mib", "ㄇㄧㄢ");
  checkEq(&container, &c, "mibf", "ㄇㄧㄢˊ");
  checkEq(&container, &c, "mibj", "ㄇㄧㄢˇ");
  checkEq(&container, &c, "mibl", "ㄇㄧㄢˋ");
  checkEq(&container, &c, "min", "ㄇㄧㄣ");
  checkEq(&container, &c, "minf", "ㄇㄧㄣˊ");
  checkEq(&container, &c, "minj", "ㄇㄧㄣˇ");
  checkEq(&container, &c, "mimf", "ㄇㄧㄥˊ");
  checkEq(&container, &c, "mimj", "ㄇㄧㄥˇ");
  checkEq(&container, &c, "miml", "ㄇㄧㄥˋ");
  checkEq(&container, &c, "muf", "ㄇㄨˊ");
  checkEq(&container, &c, "muj", "ㄇㄨˇ");
  checkEq(&container, &c, "mul", "ㄇㄨˋ");
  checkEq(&container, &c, "fa", "ㄈㄚ");
  checkEq(&container, &c, "faf", "ㄈㄚˊ");
  checkEq(&container, &c, "faj", "ㄈㄚˇ");
  checkEq(&container, &c, "fal", "ㄈㄚˋ");
  checkEq(&container, &c, "fof", "ㄈㄛˊ");
  checkEq(&container, &c, "fk", "ㄈㄟ");
  checkEq(&container, &c, "fkf", "ㄈㄟˊ");
  checkEq(&container, &c, "fkj", "ㄈㄟˇ");
  checkEq(&container, &c, "fkl", "ㄈㄟˋ");
  checkEq(&container, &c, "fv", "ㄈㄡ");
  checkEq(&container, &c, "fvf", "ㄈㄡˊ");
  checkEq(&container, &c, "fvj", "ㄈㄡˇ");
  checkEq(&container, &c, "fvl", "ㄈㄡˋ");
  checkEq(&container, &c, "fb", "ㄈㄢ");
  checkEq(&container, &c, "fbf", "ㄈㄢˊ");
  checkEq(&container, &c, "fbj", "ㄈㄢˇ");
  checkEq(&container, &c, "fbl", "ㄈㄢˋ");
  checkEq(&container, &c, "fn", "ㄈㄣ");
  checkEq(&container, &c, "fnf", "ㄈㄣˊ");
  checkEq(&container, &c, "fnj", "ㄈㄣˇ");
  checkEq(&container, &c, "fnl", "ㄈㄣˋ");
  checkEq(&container, &c, "fnd", "ㄈㄣ˙");
  checkEq(&container, &c, "fg", "ㄈㄤ");
  checkEq(&container, &c, "fgf", "ㄈㄤˊ");
  checkEq(&container, &c, "fgj", "ㄈㄤˇ");
  checkEq(&container, &c, "fgl", "ㄈㄤˋ");
  checkEq(&container, &c, "fm", "ㄈㄥ");
  checkEq(&container, &c, "fmf", "ㄈㄥˊ");
  checkEq(&container, &c, "fmj", "ㄈㄥˇ");
  checkEq(&container, &c, "fml", "ㄈㄥˋ");
  checkEq(&container, &c, "fiwl", "ㄈㄧㄠˋ");
  checkEq(&container, &c, "fu", "ㄈㄨ");
  checkEq(&container, &c, "fuf", "ㄈㄨˊ");
  checkEq(&container, &c, "fuj", "ㄈㄨˇ");
  checkEq(&container, &c, "ful", "ㄈㄨˋ");
  checkEq(&container, &c, "da", "ㄉㄚ");
  checkEq(&container, &c, "daf", "ㄉㄚˊ");
  checkEq(&container, &c, "daj", "ㄉㄚˇ");
  checkEq(&container, &c, "dal", "ㄉㄚˋ");
  checkEq(&container, &c, "dad", "ㄉㄚ˙");
  checkEq(&container, &c, "de", "ㄉㄜ");
  checkEq(&container, &c, "def", "ㄉㄜˊ");
  checkEq(&container, &c, "ded", "ㄉㄜ˙");
  checkEq(&container, &c, "dh", "ㄉㄞ");
  checkEq(&container, &c, "dhj", "ㄉㄞˇ");
  checkEq(&container, &c, "dhl", "ㄉㄞˋ");
  checkEq(&container, &c, "dkj", "ㄉㄟˇ");
  checkEq(&container, &c, "dw", "ㄉㄠ");
  checkEq(&container, &c, "dwf", "ㄉㄠˊ");
  checkEq(&container, &c, "dwj", "ㄉㄠˇ");
  checkEq(&container, &c, "dwl", "ㄉㄠˋ");
  checkEq(&container, &c, "dv", "ㄉㄡ");
  checkEq(&container, &c, "dvf", "ㄉㄡˊ");
  checkEq(&container, &c, "dvj", "ㄉㄡˇ");
  checkEq(&container, &c, "dvl", "ㄉㄡˋ");
  checkEq(&container, &c, "db", "ㄉㄢ");
  checkEq(&container, &c, "dbj", "ㄉㄢˇ");
  checkEq(&container, &c, "dbl", "ㄉㄢˋ");
  checkEq(&container, &c, "dnl", "ㄉㄣˋ");
  checkEq(&container, &c, "dg", "ㄉㄤ");
  checkEq(&container, &c, "dgj", "ㄉㄤˇ");
  checkEq(&container, &c, "dgl", "ㄉㄤˋ");
  checkEq(&container, &c, "dm", "ㄉㄥ");
  checkEq(&container, &c, "dmj", "ㄉㄥˇ");
  checkEq(&container, &c, "dml", "ㄉㄥˋ");
  checkEq(&container, &c, "di", "ㄉㄧ");
  checkEq(&container, &c, "dif", "ㄉㄧˊ");
  checkEq(&container, &c, "dij", "ㄉㄧˇ");
  checkEq(&container, &c, "dil", "ㄉㄧˋ");
  checkEq(&container, &c, "diaj", "ㄉㄧㄚˇ");
  checkEq(&container, &c, "die", "ㄉㄧㄝ");
  checkEq(&container, &c, "dief", "ㄉㄧㄝˊ");
  checkEq(&container, &c, "diej", "ㄉㄧㄝˇ");
  checkEq(&container, &c, "diel", "ㄉㄧㄝˋ");
  checkEq(&container, &c, "diw", "ㄉㄧㄠ");
  checkEq(&container, &c, "diwj", "ㄉㄧㄠˇ");
  checkEq(&container, &c, "diwl", "ㄉㄧㄠˋ");
  checkEq(&container, &c, "div", "ㄉㄧㄡ");
  checkEq(&container, &c, "dib", "ㄉㄧㄢ");
  checkEq(&container, &c, "dibf", "ㄉㄧㄢˊ");
  checkEq(&container, &c, "dibj", "ㄉㄧㄢˇ");
  checkEq(&container, &c, "dibl", "ㄉㄧㄢˋ");
  checkEq(&container, &c, "dim", "ㄉㄧㄥ");
  checkEq(&container, &c, "dimf", "ㄉㄧㄥˊ");
  checkEq(&container, &c, "dimj", "ㄉㄧㄥˇ");
  checkEq(&container, &c, "diml", "ㄉㄧㄥˋ");
  checkEq(&container, &c, "du", "ㄉㄨ");
  checkEq(&container, &c, "duf", "ㄉㄨˊ");
  checkEq(&container, &c, "duj", "ㄉㄨˇ");
  checkEq(&container, &c, "dul", "ㄉㄨˋ");
  checkEq(&container, &c, "duo", "ㄉㄨㄛ");
  checkEq(&container, &c, "duof", "ㄉㄨㄛˊ");
  checkEq(&container, &c, "duoj", "ㄉㄨㄛˇ");
  checkEq(&container, &c, "duol", "ㄉㄨㄛˋ");
  checkEq(&container, &c, "duod", "ㄉㄨㄛ˙");
  checkEq(&container, &c, "duk", "ㄉㄨㄟ");
  checkEq(&container, &c, "dukj", "ㄉㄨㄟˇ");
  checkEq(&container, &c, "dukl", "ㄉㄨㄟˋ");
  checkEq(&container, &c, "dub", "ㄉㄨㄢ");
  checkEq(&container, &c, "dubj", "ㄉㄨㄢˇ");
  checkEq(&container, &c, "dubl", "ㄉㄨㄢˋ");
  checkEq(&container, &c, "dun", "ㄉㄨㄣ");
  checkEq(&container, &c, "dunj", "ㄉㄨㄣˇ");
  checkEq(&container, &c, "dunl", "ㄉㄨㄣˋ");
  checkEq(&container, &c, "dum", "ㄉㄨㄥ");
  checkEq(&container, &c, "dumj", "ㄉㄨㄥˇ");
  checkEq(&container, &c, "duml", "ㄉㄨㄥˋ");
  checkEq(&container, &c, "ta", "ㄊㄚ");
  checkEq(&container, &c, "taj", "ㄊㄚˇ");
  checkEq(&container, &c, "tal", "ㄊㄚˋ");
  checkEq(&container, &c, "tel", "ㄊㄜˋ");
  checkEq(&container, &c, "th", "ㄊㄞ");
  checkEq(&container, &c, "thf", "ㄊㄞˊ");
  checkEq(&container, &c, "thj", "ㄊㄞˇ");
  checkEq(&container, &c, "thl", "ㄊㄞˋ");
  checkEq(&container, &c, "thd", "ㄊㄞ˙");
  checkEq(&container, &c, "tw", "ㄊㄠ");
  checkEq(&container, &c, "twf", "ㄊㄠˊ");
  checkEq(&container, &c, "twj", "ㄊㄠˇ");
  checkEq(&container, &c, "twl", "ㄊㄠˋ");
  checkEq(&container, &c, "twd", "ㄊㄠ˙");
  checkEq(&container, &c, "tv", "ㄊㄡ");
  checkEq(&container, &c, "tvf", "ㄊㄡˊ");
  checkEq(&container, &c, "tvj", "ㄊㄡˇ");
  checkEq(&container, &c, "tvl", "ㄊㄡˋ");
  checkEq(&container, &c, "tvd", "ㄊㄡ˙");
  checkEq(&container, &c, "tb", "ㄊㄢ");
  checkEq(&container, &c, "tbf", "ㄊㄢˊ");
  checkEq(&container, &c, "tbj", "ㄊㄢˇ");
  checkEq(&container, &c, "tbl", "ㄊㄢˋ");
  checkEq(&container, &c, "tg", "ㄊㄤ");
  checkEq(&container, &c, "tgf", "ㄊㄤˊ");
  checkEq(&container, &c, "tgj", "ㄊㄤˇ");
  checkEq(&container, &c, "tgl", "ㄊㄤˋ");
  checkEq(&container, &c, "tm", "ㄊㄥ");
  checkEq(&container, &c, "tmf", "ㄊㄥˊ");
  checkEq(&container, &c, "tml", "ㄊㄥˋ");
  checkEq(&container, &c, "ti", "ㄊㄧ");
  checkEq(&container, &c, "tif", "ㄊㄧˊ");
  checkEq(&container, &c, "tij", "ㄊㄧˇ");
  checkEq(&container, &c, "til", "ㄊㄧˋ");
  checkEq(&container, &c, "tie", "ㄊㄧㄝ");
  checkEq(&container, &c, "tief", "ㄊㄧㄝˊ");
  checkEq(&container, &c, "tiej", "ㄊㄧㄝˇ");
  checkEq(&container, &c, "tiel", "ㄊㄧㄝˋ");
  checkEq(&container, &c, "tiw", "ㄊㄧㄠ");
  checkEq(&container, &c, "tiwf", "ㄊㄧㄠˊ");
  checkEq(&container, &c, "tiwj", "ㄊㄧㄠˇ");
  checkEq(&container, &c, "tiwl", "ㄊㄧㄠˋ");
  checkEq(&container, &c, "tib", "ㄊㄧㄢ");
  checkEq(&container, &c, "tibf", "ㄊㄧㄢˊ");
  checkEq(&container, &c, "tibj", "ㄊㄧㄢˇ");
  checkEq(&container, &c, "tibl", "ㄊㄧㄢˋ");
  checkEq(&container, &c, "tim", "ㄊㄧㄥ");
  checkEq(&container, &c, "timf", "ㄊㄧㄥˊ");
  checkEq(&container, &c, "timj", "ㄊㄧㄥˇ");
  checkEq(&container, &c, "timl", "ㄊㄧㄥˋ");
  checkEq(&container, &c, "tu", "ㄊㄨ");
  checkEq(&container, &c, "tuf", "ㄊㄨˊ");
  checkEq(&container, &c, "tuj", "ㄊㄨˇ");
  checkEq(&container, &c, "tul", "ㄊㄨˋ");
  checkEq(&container, &c, "tuo", "ㄊㄨㄛ");
  checkEq(&container, &c, "tuof", "ㄊㄨㄛˊ");
  checkEq(&container, &c, "tuoj", "ㄊㄨㄛˇ");
  checkEq(&container, &c, "tuol", "ㄊㄨㄛˋ");
  checkEq(&container, &c, "tuk", "ㄊㄨㄟ");
  checkEq(&container, &c, "tukf", "ㄊㄨㄟˊ");
  checkEq(&container, &c, "tukj", "ㄊㄨㄟˇ");
  checkEq(&container, &c, "tukl", "ㄊㄨㄟˋ");
  checkEq(&container, &c, "tub", "ㄊㄨㄢ");
  checkEq(&container, &c, "tubf", "ㄊㄨㄢˊ");
  checkEq(&container, &c, "tubj", "ㄊㄨㄢˇ");
  checkEq(&container, &c, "tubl", "ㄊㄨㄢˋ");
  checkEq(&container, &c, "tun", "ㄊㄨㄣ");
  checkEq(&container, &c, "tunf", "ㄊㄨㄣˊ");
  checkEq(&container, &c, "tunj", "ㄊㄨㄣˇ");
  checkEq(&container, &c, "tunl", "ㄊㄨㄣˋ");
  checkEq(&container, &c, "tum", "ㄊㄨㄥ");
  checkEq(&container, &c, "tumf", "ㄊㄨㄥˊ");
  checkEq(&container, &c, "tumj", "ㄊㄨㄥˇ");
  checkEq(&container, &c, "tuml", "ㄊㄨㄥˋ");
  checkEq(&container, &c, "na", "ㄋㄚ");
  checkEq(&container, &c, "naf", "ㄋㄚˊ");
  checkEq(&container, &c, "naj", "ㄋㄚˇ");
  checkEq(&container, &c, "nal", "ㄋㄚˋ");
  checkEq(&container, &c, "nad", "ㄋㄚ˙");
  checkEq(&container, &c, "nel", "ㄋㄜˋ");
  checkEq(&container, &c, "ned", "ㄋㄜ˙");
  checkEq(&container, &c, "nhf", "ㄋㄞˊ");
  checkEq(&container, &c, "nhj", "ㄋㄞˇ");
  checkEq(&container, &c, "nhl", "ㄋㄞˋ");
  checkEq(&container, &c, "nkf", "ㄋㄟˊ");
  checkEq(&container, &c, "nkj", "ㄋㄟˇ");
  checkEq(&container, &c, "nkl", "ㄋㄟˋ");
  checkEq(&container, &c, "nw", "ㄋㄠ");
  checkEq(&container, &c, "nwf", "ㄋㄠˊ");
  checkEq(&container, &c, "nwj", "ㄋㄠˇ");
  checkEq(&container, &c, "nwl", "ㄋㄠˋ");
  checkEq(&container, &c, "nvf", "ㄋㄡˊ");
  checkEq(&container, &c, "nvj", "ㄋㄡˇ");
  checkEq(&container, &c, "nvl", "ㄋㄡˋ");
  checkEq(&container, &c, "nb", "ㄋㄢ");
  checkEq(&container, &c, "nbf", "ㄋㄢˊ");
  checkEq(&container, &c, "nbj", "ㄋㄢˇ");
  checkEq(&container, &c, "nbl", "ㄋㄢˋ");
  checkEq(&container, &c, "nnj", "ㄋㄣˇ");
  checkEq(&container, &c, "nnl", "ㄋㄣˋ");
  checkEq(&container, &c, "ng", "ㄋㄤ");
  checkEq(&container, &c, "ngf", "ㄋㄤˊ");
  checkEq(&container, &c, "ngj", "ㄋㄤˇ");
  checkEq(&container, &c, "ngl", "ㄋㄤˋ");
  checkEq(&container, &c, "ngd", "ㄋㄤ˙");
  checkEq(&container, &c, "nmf", "ㄋㄥˊ");
  checkEq(&container, &c, "nmj", "ㄋㄥˇ");
  checkEq(&container, &c, "ni", "ㄋㄧ");
  checkEq(&container, &c, "nif", "ㄋㄧˊ");
  checkEq(&container, &c, "nij", "ㄋㄧˇ");
  checkEq(&container, &c, "nil", "ㄋㄧˋ");
  checkEq(&container, &c, "nie", "ㄋㄧㄝ");
  checkEq(&container, &c, "nief", "ㄋㄧㄝˊ");
  checkEq(&container, &c, "niel", "ㄋㄧㄝˋ");
  checkEq(&container, &c, "niwj", "ㄋㄧㄠˇ");
  checkEq(&container, &c, "niwl", "ㄋㄧㄠˋ");
  checkEq(&container, &c, "niv", "ㄋㄧㄡ");
  checkEq(&container, &c, "nivf", "ㄋㄧㄡˊ");
  checkEq(&container, &c, "nivj", "ㄋㄧㄡˇ");
  checkEq(&container, &c, "nivl", "ㄋㄧㄡˋ");
  checkEq(&container, &c, "nib", "ㄋㄧㄢ");
  checkEq(&container, &c, "nibf", "ㄋㄧㄢˊ");
  checkEq(&container, &c, "nibj", "ㄋㄧㄢˇ");
  checkEq(&container, &c, "nibl", "ㄋㄧㄢˋ");
  checkEq(&container, &c, "nin", "ㄋㄧㄣ");
  checkEq(&container, &c, "ninf", "ㄋㄧㄣˊ");
  checkEq(&container, &c, "ninj", "ㄋㄧㄣˇ");
  checkEq(&container, &c, "ninl", "ㄋㄧㄣˋ");
  checkEq(&container, &c, "nigf", "ㄋㄧㄤˊ");
  checkEq(&container, &c, "nigj", "ㄋㄧㄤˇ");
  checkEq(&container, &c, "nigl", "ㄋㄧㄤˋ");
  checkEq(&container, &c, "nimf", "ㄋㄧㄥˊ");
  checkEq(&container, &c, "nimj", "ㄋㄧㄥˇ");
  checkEq(&container, &c, "niml", "ㄋㄧㄥˋ");
  checkEq(&container, &c, "nuf", "ㄋㄨˊ");
  checkEq(&container, &c, "nuj", "ㄋㄨˇ");
  checkEq(&container, &c, "nul", "ㄋㄨˋ");
  checkEq(&container, &c, "nuof", "ㄋㄨㄛˊ");
  checkEq(&container, &c, "nuoj", "ㄋㄨㄛˇ");
  checkEq(&container, &c, "nuol", "ㄋㄨㄛˋ");
  checkEq(&container, &c, "nukf", "ㄋㄨㄟˊ");
  checkEq(&container, &c, "nubf", "ㄋㄨㄢˊ");
  checkEq(&container, &c, "nubj", "ㄋㄨㄢˇ");
  checkEq(&container, &c, "nubl", "ㄋㄨㄢˋ");
  checkEq(&container, &c, "nunf", "ㄋㄨㄣˊ");
  checkEq(&container, &c, "numf", "ㄋㄨㄥˊ");
  checkEq(&container, &c, "numj", "ㄋㄨㄥˇ");
  checkEq(&container, &c, "numl", "ㄋㄨㄥˋ");
  checkEq(&container, &c, "nyf", "ㄋㄩˊ");
  checkEq(&container, &c, "nyj", "ㄋㄩˇ");
  checkEq(&container, &c, "nyl", "ㄋㄩˋ");
  checkEq(&container, &c, "nyel", "ㄋㄩㄝˋ");
  checkEq(&container, &c, "la", "ㄌㄚ");
  checkEq(&container, &c, "laf", "ㄌㄚˊ");
  checkEq(&container, &c, "laj", "ㄌㄚˇ");
  checkEq(&container, &c, "lal", "ㄌㄚˋ");
  checkEq(&container, &c, "lad", "ㄌㄚ˙");
  checkEq(&container, &c, "lo", "ㄌㄛ");
  checkEq(&container, &c, "lod", "ㄌㄛ˙");
  checkEq(&container, &c, "le", "ㄌㄜ");
  checkEq(&container, &c, "lef", "ㄌㄜˊ");
  checkEq(&container, &c, "lel", "ㄌㄜˋ");
  checkEq(&container, &c, "led", "ㄌㄜ˙");
  checkEq(&container, &c, "lhf", "ㄌㄞˊ");
  checkEq(&container, &c, "lhj", "ㄌㄞˇ");
  checkEq(&container, &c, "lhl", "ㄌㄞˋ");
  checkEq(&container, &c, "lk", "ㄌㄟ");
  checkEq(&container, &c, "lkf", "ㄌㄟˊ");
  checkEq(&container, &c, "lkj", "ㄌㄟˇ");
  checkEq(&container, &c, "lkl", "ㄌㄟˋ");
  checkEq(&container, &c, "lkd", "ㄌㄟ˙");
  checkEq(&container, &c, "lw", "ㄌㄠ");
  checkEq(&container, &c, "lwf", "ㄌㄠˊ");
  checkEq(&container, &c, "lwj", "ㄌㄠˇ");
  checkEq(&container, &c, "lwl", "ㄌㄠˋ");
  checkEq(&container, &c, "lv", "ㄌㄡ");
  checkEq(&container, &c, "lvf", "ㄌㄡˊ");
  checkEq(&container, &c, "lvj", "ㄌㄡˇ");
  checkEq(&container, &c, "lvl", "ㄌㄡˋ");
  checkEq(&container, &c, "lvd", "ㄌㄡ˙");
  checkEq(&container, &c, "lbf", "ㄌㄢˊ");
  checkEq(&container, &c, "lbj", "ㄌㄢˇ");
  checkEq(&container, &c, "lbl", "ㄌㄢˋ");
  checkEq(&container, &c, "lg", "ㄌㄤ");
  checkEq(&container, &c, "lgf", "ㄌㄤˊ");
  checkEq(&container, &c, "lgj", "ㄌㄤˇ");
  checkEq(&container, &c, "lgl", "ㄌㄤˋ");
  checkEq(&container, &c, "lm", "ㄌㄥ");
  checkEq(&container, &c, "lmf", "ㄌㄥˊ");
  checkEq(&container, &c, "lmj", "ㄌㄥˇ");
  checkEq(&container, &c, "lml", "ㄌㄥˋ");
  checkEq(&container, &c, "li", "ㄌㄧ");
  checkEq(&container, &c, "lif", "ㄌㄧˊ");
  checkEq(&container, &c, "lij", "ㄌㄧˇ");
  checkEq(&container, &c, "lil", "ㄌㄧˋ");
  checkEq(&container, &c, "lid", "ㄌㄧ˙");
  checkEq(&container, &c, "liaj", "ㄌㄧㄚˇ");
  checkEq(&container, &c, "lie", "ㄌㄧㄝ");
  checkEq(&container, &c, "lief", "ㄌㄧㄝˊ");
  checkEq(&container, &c, "liej", "ㄌㄧㄝˇ");
  checkEq(&container, &c, "liel", "ㄌㄧㄝˋ");
  checkEq(&container, &c, "liw", "ㄌㄧㄠ");
  checkEq(&container, &c, "liwf", "ㄌㄧㄠˊ");
  checkEq(&container, &c, "liwj", "ㄌㄧㄠˇ");
  checkEq(&container, &c, "liwl", "ㄌㄧㄠˋ");
  checkEq(&container, &c, "liv", "ㄌㄧㄡ");
  checkEq(&container, &c, "livf", "ㄌㄧㄡˊ");
  checkEq(&container, &c, "livj", "ㄌㄧㄡˇ");
  checkEq(&container, &c, "livl", "ㄌㄧㄡˋ");
  checkEq(&container, &c, "lib", "ㄌㄧㄢ");
  checkEq(&container, &c, "libf", "ㄌㄧㄢˊ");
  checkEq(&container, &c, "libj", "ㄌㄧㄢˇ");
  checkEq(&container, &c, "libl", "ㄌㄧㄢˋ");
  checkEq(&container, &c, "linf", "ㄌㄧㄣˊ");
  checkEq(&container, &c, "linj", "ㄌㄧㄣˇ");
  checkEq(&container, &c, "linl", "ㄌㄧㄣˋ");
  checkEq(&container, &c, "ligf", "ㄌㄧㄤˊ");
  checkEq(&container, &c, "ligj", "ㄌㄧㄤˇ");
  checkEq(&container, &c, "ligl", "ㄌㄧㄤˋ");
  checkEq(&container, &c, "lim", "ㄌㄧㄥ");
  checkEq(&container, &c, "limf", "ㄌㄧㄥˊ");
  checkEq(&container, &c, "limj", "ㄌㄧㄥˇ");
  checkEq(&container, &c, "liml", "ㄌㄧㄥˋ");
  checkEq(&container, &c, "lu", "ㄌㄨ");
  checkEq(&container, &c, "luf", "ㄌㄨˊ");
  checkEq(&container, &c, "luj", "ㄌㄨˇ");
  checkEq(&container, &c, "lul", "ㄌㄨˋ");
  checkEq(&container, &c, "luo", "ㄌㄨㄛ");
  checkEq(&container, &c, "luof", "ㄌㄨㄛˊ");
  checkEq(&container, &c, "luoj", "ㄌㄨㄛˇ");
  checkEq(&container, &c, "luol", "ㄌㄨㄛˋ");
  checkEq(&container, &c, "luod", "ㄌㄨㄛ˙");
  checkEq(&container, &c, "lubf", "ㄌㄨㄢˊ");
  checkEq(&container, &c, "lubj", "ㄌㄨㄢˇ");
  checkEq(&container, &c, "lubl", "ㄌㄨㄢˋ");
  checkEq(&container, &c, "lun", "ㄌㄨㄣ");
  checkEq(&container, &c, "lunf", "ㄌㄨㄣˊ");
  checkEq(&container, &c, "lunj", "ㄌㄨㄣˇ");
  checkEq(&container, &c, "lunl", "ㄌㄨㄣˋ");
  checkEq(&container, &c, "lum", "ㄌㄨㄥ");
  checkEq(&container, &c, "lumf", "ㄌㄨㄥˊ");
  checkEq(&container, &c, "lumj", "ㄌㄨㄥˇ");
  checkEq(&container, &c, "luml", "ㄌㄨㄥˋ");
  checkEq(&container, &c, "ly", "ㄌㄩ");
  checkEq(&container, &c, "lyf", "ㄌㄩˊ");
  checkEq(&container, &c, "lyj", "ㄌㄩˇ");
  checkEq(&container, &c, "lyl", "ㄌㄩˋ");
  checkEq(&container, &c, "lye", "ㄌㄩㄝ");
  checkEq(&container, &c, "lyej", "ㄌㄩㄝˇ");
  checkEq(&container, &c, "lyel", "ㄌㄩㄝˋ");
  checkEq(&container, &c, "lybf", "ㄌㄩㄢˊ");
  checkEq(&container, &c, "lybj", "ㄌㄩㄢˇ");
  checkEq(&container, &c, "ga", "ㄍㄚ");
  checkEq(&container, &c, "gaf", "ㄍㄚˊ");
  checkEq(&container, &c, "gaj", "ㄍㄚˇ");
  checkEq(&container, &c, "gal", "ㄍㄚˋ");
  checkEq(&container, &c, "gad", "ㄍㄚ˙");
  checkEq(&container, &c, "ge", "ㄍㄜ");
  checkEq(&container, &c, "gef", "ㄍㄜˊ");
  checkEq(&container, &c, "gej", "ㄍㄜˇ");
  checkEq(&container, &c, "gel", "ㄍㄜˋ");
  checkEq(&container, &c, "ged", "ㄍㄜ˙");
  checkEq(&container, &c, "gh", "ㄍㄞ");
  checkEq(&container, &c, "ghj", "ㄍㄞˇ");
  checkEq(&container, &c, "ghl", "ㄍㄞˋ");
  checkEq(&container, &c, "gkj", "ㄍㄟˇ");
  checkEq(&container, &c, "gw", "ㄍㄠ");
  checkEq(&container, &c, "gwj", "ㄍㄠˇ");
  checkEq(&container, &c, "gwl", "ㄍㄠˋ");
  checkEq(&container, &c, "gv", "ㄍㄡ");
  checkEq(&container, &c, "gvj", "ㄍㄡˇ");
  checkEq(&container, &c, "gvl", "ㄍㄡˋ");
  checkEq(&container, &c, "gb", "ㄍㄢ");
  checkEq(&container, &c, "gbj", "ㄍㄢˇ");
  checkEq(&container, &c, "gbl", "ㄍㄢˋ");
  checkEq(&container, &c, "gn", "ㄍㄣ");
  checkEq(&container, &c, "gnf", "ㄍㄣˊ");
  checkEq(&container, &c, "gnj", "ㄍㄣˇ");
  checkEq(&container, &c, "gnl", "ㄍㄣˋ");
  checkEq(&container, &c, "gg", "ㄍㄤ");
  checkEq(&container, &c, "ggj", "ㄍㄤˇ");
  checkEq(&container, &c, "ggl", "ㄍㄤˋ");
  checkEq(&container, &c, "gm", "ㄍㄥ");
  checkEq(&container, &c, "gmj", "ㄍㄥˇ");
  checkEq(&container, &c, "gml", "ㄍㄥˋ");
  checkEq(&container, &c, "gu", "ㄍㄨ");
  checkEq(&container, &c, "guf", "ㄍㄨˊ");
  checkEq(&container, &c, "guj", "ㄍㄨˇ");
  checkEq(&container, &c, "gul", "ㄍㄨˋ");
  checkEq(&container, &c, "gua", "ㄍㄨㄚ");
  checkEq(&container, &c, "guaf", "ㄍㄨㄚˊ");
  checkEq(&container, &c, "guaj", "ㄍㄨㄚˇ");
  checkEq(&container, &c, "gual", "ㄍㄨㄚˋ");
  checkEq(&container, &c, "guo", "ㄍㄨㄛ");
  checkEq(&container, &c, "guof", "ㄍㄨㄛˊ");
  checkEq(&container, &c, "guoj", "ㄍㄨㄛˇ");
  checkEq(&container, &c, "guol", "ㄍㄨㄛˋ");
  checkEq(&container, &c, "guh", "ㄍㄨㄞ");
  checkEq(&container, &c, "guhj", "ㄍㄨㄞˇ");
  checkEq(&container, &c, "guhl", "ㄍㄨㄞˋ");
  checkEq(&container, &c, "guk", "ㄍㄨㄟ");
  checkEq(&container, &c, "gukj", "ㄍㄨㄟˇ");
  checkEq(&container, &c, "gukl", "ㄍㄨㄟˋ");
  checkEq(&container, &c, "gub", "ㄍㄨㄢ");
  checkEq(&container, &c, "gubj", "ㄍㄨㄢˇ");
  checkEq(&container, &c, "gubl", "ㄍㄨㄢˋ");
  checkEq(&container, &c, "gun", "ㄍㄨㄣ");
  checkEq(&container, &c, "gunj", "ㄍㄨㄣˇ");
  checkEq(&container, &c, "gunl", "ㄍㄨㄣˋ");
  checkEq(&container, &c, "gug", "ㄍㄨㄤ");
  checkEq(&container, &c, "gugj", "ㄍㄨㄤˇ");
  checkEq(&container, &c, "gugl", "ㄍㄨㄤˋ");
  checkEq(&container, &c, "gum", "ㄍㄨㄥ");
  checkEq(&container, &c, "gumf", "ㄍㄨㄥˊ");
  checkEq(&container, &c, "gumj", "ㄍㄨㄥˇ");
  checkEq(&container, &c, "guml", "ㄍㄨㄥˋ");
  checkEq(&container, &c, "ka", "ㄎㄚ");
  checkEq(&container, &c, "kaj", "ㄎㄚˇ");
  checkEq(&container, &c, "kal", "ㄎㄚˋ");
  checkEq(&container, &c, "ke", "ㄎㄜ");
  checkEq(&container, &c, "kef", "ㄎㄜˊ");
  checkEq(&container, &c, "kej", "ㄎㄜˇ");
  checkEq(&container, &c, "kel", "ㄎㄜˋ");
  checkEq(&container, &c, "kh", "ㄎㄞ");
  checkEq(&container, &c, "khj", "ㄎㄞˇ");
  checkEq(&container, &c, "khl", "ㄎㄞˋ");
  checkEq(&container, &c, "kw", "ㄎㄠ");
  checkEq(&container, &c, "kwj", "ㄎㄠˇ");
  checkEq(&container, &c, "kwl", "ㄎㄠˋ");
  checkEq(&container, &c, "kv", "ㄎㄡ");
  checkEq(&container, &c, "kvj", "ㄎㄡˇ");
  checkEq(&container, &c, "kvl", "ㄎㄡˋ");
  checkEq(&container, &c, "kb", "ㄎㄢ");
  checkEq(&container, &c, "kbj", "ㄎㄢˇ");
  checkEq(&container, &c, "kbl", "ㄎㄢˋ");
  checkEq(&container, &c, "kn", "ㄎㄣ");
  checkEq(&container, &c, "knj", "ㄎㄣˇ");
  checkEq(&container, &c, "knl", "ㄎㄣˋ");
  checkEq(&container, &c, "kg", "ㄎㄤ");
  checkEq(&container, &c, "kgf", "ㄎㄤˊ");
  checkEq(&container, &c, "kgj", "ㄎㄤˇ");
  checkEq(&container, &c, "kgl", "ㄎㄤˋ");
  checkEq(&container, &c, "km", "ㄎㄥ");
  checkEq(&container, &c, "kmj", "ㄎㄥˇ");
  checkEq(&container, &c, "ku", "ㄎㄨ");
  checkEq(&container, &c, "kuf", "ㄎㄨˊ");
  checkEq(&container, &c, "kuj", "ㄎㄨˇ");
  checkEq(&container, &c, "kul", "ㄎㄨˋ");
  checkEq(&container, &c, "kua", "ㄎㄨㄚ");
  checkEq(&container, &c, "kuaj", "ㄎㄨㄚˇ");
  checkEq(&container, &c, "kual", "ㄎㄨㄚˋ");
  checkEq(&container, &c, "kuol", "ㄎㄨㄛˋ");
  checkEq(&container, &c, "kuh", "ㄎㄨㄞ");
  checkEq(&container, &c, "kuhj", "ㄎㄨㄞˇ");
  checkEq(&container, &c, "kuhl", "ㄎㄨㄞˋ");
  checkEq(&container, &c, "kuk", "ㄎㄨㄟ");
  checkEq(&container, &c, "kukf", "ㄎㄨㄟˊ");
  checkEq(&container, &c, "kukj", "ㄎㄨㄟˇ");
  checkEq(&container, &c, "kukl", "ㄎㄨㄟˋ");
  checkEq(&container, &c, "kub", "ㄎㄨㄢ");
  checkEq(&container, &c, "kubj", "ㄎㄨㄢˇ");
  checkEq(&container, &c, "kubl", "ㄎㄨㄢˋ");
  checkEq(&container, &c, "kun", "ㄎㄨㄣ");
  checkEq(&container, &c, "kunj", "ㄎㄨㄣˇ");
  checkEq(&container, &c, "kunl", "ㄎㄨㄣˋ");
  checkEq(&container, &c, "kug", "ㄎㄨㄤ");
  checkEq(&container, &c, "kugf", "ㄎㄨㄤˊ");
  checkEq(&container, &c, "kugj", "ㄎㄨㄤˇ");
  checkEq(&container, &c, "kugl", "ㄎㄨㄤˋ");
  checkEq(&container, &c, "kum", "ㄎㄨㄥ");
  checkEq(&container, &c, "kumj", "ㄎㄨㄥˇ");
  checkEq(&container, &c, "kuml", "ㄎㄨㄥˋ");
  checkEq(&container, &c, "ha", "ㄏㄚ");
  checkEq(&container, &c, "haf", "ㄏㄚˊ");
  checkEq(&container, &c, "haj", "ㄏㄚˇ");
  checkEq(&container, &c, "he", "ㄏㄜ");
  checkEq(&container, &c, "hef", "ㄏㄜˊ");
  checkEq(&container, &c, "hej", "ㄏㄜˇ");
  checkEq(&container, &c, "hel", "ㄏㄜˋ");
  checkEq(&container, &c, "hh", "ㄏㄞ");
  checkEq(&container, &c, "hhf", "ㄏㄞˊ");
  checkEq(&container, &c, "hhj", "ㄏㄞˇ");
  checkEq(&container, &c, "hhl", "ㄏㄞˋ");
  checkEq(&container, &c, "hk", "ㄏㄟ");
  checkEq(&container, &c, "hkj", "ㄏㄟˇ");
  checkEq(&container, &c, "hw", "ㄏㄠ");
  checkEq(&container, &c, "hwf", "ㄏㄠˊ");
  checkEq(&container, &c, "hwj", "ㄏㄠˇ");
  checkEq(&container, &c, "hwl", "ㄏㄠˋ");
  checkEq(&container, &c, "hv", "ㄏㄡ");
  checkEq(&container, &c, "hvf", "ㄏㄡˊ");
  checkEq(&container, &c, "hvj", "ㄏㄡˇ");
  checkEq(&container, &c, "hvl", "ㄏㄡˋ");
  checkEq(&container, &c, "hb", "ㄏㄢ");
  checkEq(&container, &c, "hbf", "ㄏㄢˊ");
  checkEq(&container, &c, "hbj", "ㄏㄢˇ");
  checkEq(&container, &c, "hbl", "ㄏㄢˋ");
  checkEq(&container, &c, "hn", "ㄏㄣ");
  checkEq(&container, &c, "hnf", "ㄏㄣˊ");
  checkEq(&container, &c, "hnj", "ㄏㄣˇ");
  checkEq(&container, &c, "hnl", "ㄏㄣˋ");
  checkEq(&container, &c, "hg", "ㄏㄤ");
  checkEq(&container, &c, "hgf", "ㄏㄤˊ");
  checkEq(&container, &c, "hgj", "ㄏㄤˇ");
  checkEq(&container, &c, "hgl", "ㄏㄤˋ");
  checkEq(&container, &c, "hm", "ㄏㄥ");
  checkEq(&container, &c, "hmf", "ㄏㄥˊ");
  checkEq(&container, &c, "hml", "ㄏㄥˋ");
  checkEq(&container, &c, "hu", "ㄏㄨ");
  checkEq(&container, &c, "huf", "ㄏㄨˊ");
  checkEq(&container, &c, "huj", "ㄏㄨˇ");
  checkEq(&container, &c, "hul", "ㄏㄨˋ");
  checkEq(&container, &c, "hua", "ㄏㄨㄚ");
  checkEq(&container, &c, "huaf", "ㄏㄨㄚˊ");
  checkEq(&container, &c, "huaj", "ㄏㄨㄚˇ");
  checkEq(&container, &c, "hual", "ㄏㄨㄚˋ");
  checkEq(&container, &c, "huo", "ㄏㄨㄛ");
  checkEq(&container, &c, "huof", "ㄏㄨㄛˊ");
  checkEq(&container, &c, "huoj", "ㄏㄨㄛˇ");
  checkEq(&container, &c, "huol", "ㄏㄨㄛˋ");
  checkEq(&container, &c, "huod", "ㄏㄨㄛ˙");
  checkEq(&container, &c, "huhf", "ㄏㄨㄞˊ");
  checkEq(&container, &c, "huhl", "ㄏㄨㄞˋ");
  checkEq(&container, &c, "huk", "ㄏㄨㄟ");
  checkEq(&container, &c, "hukf", "ㄏㄨㄟˊ");
  checkEq(&container, &c, "hukj", "ㄏㄨㄟˇ");
  checkEq(&container, &c, "hukl", "ㄏㄨㄟˋ");
  checkEq(&container, &c, "hub", "ㄏㄨㄢ");
  checkEq(&container, &c, "hubf", "ㄏㄨㄢˊ");
  checkEq(&container, &c, "hubj", "ㄏㄨㄢˇ");
  checkEq(&container, &c, "hubl", "ㄏㄨㄢˋ");
  checkEq(&container, &c, "hun", "ㄏㄨㄣ");
  checkEq(&container, &c, "hunf", "ㄏㄨㄣˊ");
  checkEq(&container, &c, "hunj", "ㄏㄨㄣˇ");
  checkEq(&container, &c, "hunl", "ㄏㄨㄣˋ");
  checkEq(&container, &c, "hug", "ㄏㄨㄤ");
  checkEq(&container, &c, "hugf", "ㄏㄨㄤˊ");
  checkEq(&container, &c, "hugj", "ㄏㄨㄤˇ");
  checkEq(&container, &c, "hugl", "ㄏㄨㄤˋ");
  checkEq(&container, &c, "hugd", "ㄏㄨㄤ˙");
  checkEq(&container, &c, "hum", "ㄏㄨㄥ");
  checkEq(&container, &c, "humf", "ㄏㄨㄥˊ");
  checkEq(&container, &c, "humj", "ㄏㄨㄥˇ");
  checkEq(&container, &c, "huml", "ㄏㄨㄥˋ");
  checkEq(&container, &c, "ji", "ㄐㄧ");
  checkEq(&container, &c, "jif", "ㄐㄧˊ");
  checkEq(&container, &c, "jij", "ㄐㄧˇ");
  checkEq(&container, &c, "jil", "ㄐㄧˋ");
  checkEq(&container, &c, "jia", "ㄐㄧㄚ");
  checkEq(&container, &c, "jiaf", "ㄐㄧㄚˊ");
  checkEq(&container, &c, "jiaj", "ㄐㄧㄚˇ");
  checkEq(&container, &c, "jial", "ㄐㄧㄚˋ");
  checkEq(&container, &c, "jie", "ㄐㄧㄝ");
  checkEq(&container, &c, "jief", "ㄐㄧㄝˊ");
  checkEq(&container, &c, "jiej", "ㄐㄧㄝˇ");
  checkEq(&container, &c, "jiel", "ㄐㄧㄝˋ");
  checkEq(&container, &c, "jied", "ㄐㄧㄝ˙");
  checkEq(&container, &c, "jiw", "ㄐㄧㄠ");
  checkEq(&container, &c, "jiwf", "ㄐㄧㄠˊ");
  checkEq(&container, &c, "jiwj", "ㄐㄧㄠˇ");
  checkEq(&container, &c, "jiwl", "ㄐㄧㄠˋ");
  checkEq(&container, &c, "jiv", "ㄐㄧㄡ");
  checkEq(&container, &c, "jivj", "ㄐㄧㄡˇ");
  checkEq(&container, &c, "jivl", "ㄐㄧㄡˋ");
  checkEq(&container, &c, "jib", "ㄐㄧㄢ");
  checkEq(&container, &c, "jibj", "ㄐㄧㄢˇ");
  checkEq(&container, &c, "jibl", "ㄐㄧㄢˋ");
  checkEq(&container, &c, "jin", "ㄐㄧㄣ");
  checkEq(&container, &c, "jinj", "ㄐㄧㄣˇ");
  checkEq(&container, &c, "jinl", "ㄐㄧㄣˋ");
  checkEq(&container, &c, "jig", "ㄐㄧㄤ");
  checkEq(&container, &c, "jigf", "ㄐㄧㄤˊ");
  checkEq(&container, &c, "jigj", "ㄐㄧㄤˇ");
  checkEq(&container, &c, "jigl", "ㄐㄧㄤˋ");
  checkEq(&container, &c, "jim", "ㄐㄧㄥ");
  checkEq(&container, &c, "jimj", "ㄐㄧㄥˇ");
  checkEq(&container, &c, "jiml", "ㄐㄧㄥˋ");
  checkEq(&container, &c, "jy", "ㄐㄩ");
  checkEq(&container, &c, "jyf", "ㄐㄩˊ");
  checkEq(&container, &c, "jyj", "ㄐㄩˇ");
  checkEq(&container, &c, "jyl", "ㄐㄩˋ");
  checkEq(&container, &c, "jye", "ㄐㄩㄝ");
  checkEq(&container, &c, "jyef", "ㄐㄩㄝˊ");
  checkEq(&container, &c, "jyej", "ㄐㄩㄝˇ");
  checkEq(&container, &c, "jyel", "ㄐㄩㄝˋ");
  checkEq(&container, &c, "jyb", "ㄐㄩㄢ");
  checkEq(&container, &c, "jybj", "ㄐㄩㄢˇ");
  checkEq(&container, &c, "jybl", "ㄐㄩㄢˋ");
  checkEq(&container, &c, "jyn", "ㄐㄩㄣ");
  checkEq(&container, &c, "jynf", "ㄐㄩㄣˊ");
  checkEq(&container, &c, "jynj", "ㄐㄩㄣˇ");
  checkEq(&container, &c, "jynl", "ㄐㄩㄣˋ");
  checkEq(&container, &c, "jym", "ㄐㄩㄥ");
  checkEq(&container, &c, "jymj", "ㄐㄩㄥˇ");
  checkEq(&container, &c, "jyml", "ㄐㄩㄥˋ");
  // checkEq(&container, &c, "qd", "ㄑ˙");
  checkEq(&container, &c, "qi", "ㄑㄧ");
  checkEq(&container, &c, "qif", "ㄑㄧˊ");
  checkEq(&container, &c, "qij", "ㄑㄧˇ");
  checkEq(&container, &c, "qil", "ㄑㄧˋ");
  checkEq(&container, &c, "qia", "ㄑㄧㄚ");
  checkEq(&container, &c, "qiaf", "ㄑㄧㄚˊ");
  checkEq(&container, &c, "qiaj", "ㄑㄧㄚˇ");
  checkEq(&container, &c, "qial", "ㄑㄧㄚˋ");
  checkEq(&container, &c, "qie", "ㄑㄧㄝ");
  checkEq(&container, &c, "qief", "ㄑㄧㄝˊ");
  checkEq(&container, &c, "qiej", "ㄑㄧㄝˇ");
  checkEq(&container, &c, "qiel", "ㄑㄧㄝˋ");
  checkEq(&container, &c, "qiw", "ㄑㄧㄠ");
  checkEq(&container, &c, "qiwf", "ㄑㄧㄠˊ");
  checkEq(&container, &c, "qiwj", "ㄑㄧㄠˇ");
  checkEq(&container, &c, "qiwl", "ㄑㄧㄠˋ");
  checkEq(&container, &c, "qiv", "ㄑㄧㄡ");
  checkEq(&container, &c, "qivf", "ㄑㄧㄡˊ");
  checkEq(&container, &c, "qivj", "ㄑㄧㄡˇ");
  checkEq(&container, &c, "qivl", "ㄑㄧㄡˋ");
  checkEq(&container, &c, "qib", "ㄑㄧㄢ");
  checkEq(&container, &c, "qibf", "ㄑㄧㄢˊ");
  checkEq(&container, &c, "qibj", "ㄑㄧㄢˇ");
  checkEq(&container, &c, "qibl", "ㄑㄧㄢˋ");
  checkEq(&container, &c, "qin", "ㄑㄧㄣ");
  checkEq(&container, &c, "qinf", "ㄑㄧㄣˊ");
  checkEq(&container, &c, "qinj", "ㄑㄧㄣˇ");
  checkEq(&container, &c, "qinl", "ㄑㄧㄣˋ");
  checkEq(&container, &c, "qig", "ㄑㄧㄤ");
  checkEq(&container, &c, "qigf", "ㄑㄧㄤˊ");
  checkEq(&container, &c, "qigj", "ㄑㄧㄤˇ");
  checkEq(&container, &c, "qigl", "ㄑㄧㄤˋ");
  checkEq(&container, &c, "qim", "ㄑㄧㄥ");
  checkEq(&container, &c, "qimf", "ㄑㄧㄥˊ");
  checkEq(&container, &c, "qimj", "ㄑㄧㄥˇ");
  checkEq(&container, &c, "qiml", "ㄑㄧㄥˋ");
  checkEq(&container, &c, "qy", "ㄑㄩ");
  checkEq(&container, &c, "qyf", "ㄑㄩˊ");
  checkEq(&container, &c, "qyj", "ㄑㄩˇ");
  checkEq(&container, &c, "qyl", "ㄑㄩˋ");
  checkEq(&container, &c, "qye", "ㄑㄩㄝ");
  checkEq(&container, &c, "qyef", "ㄑㄩㄝˊ");
  checkEq(&container, &c, "qyel", "ㄑㄩㄝˋ");
  checkEq(&container, &c, "qyb", "ㄑㄩㄢ");
  checkEq(&container, &c, "qybf", "ㄑㄩㄢˊ");
  checkEq(&container, &c, "qybj", "ㄑㄩㄢˇ");
  checkEq(&container, &c, "qybl", "ㄑㄩㄢˋ");
  checkEq(&container, &c, "qyn", "ㄑㄩㄣ");
  checkEq(&container, &c, "qynf", "ㄑㄩㄣˊ");
  checkEq(&container, &c, "qynj", "ㄑㄩㄣˇ");
  checkEq(&container, &c, "qynl", "ㄑㄩㄣˋ");
  checkEq(&container, &c, "qym", "ㄑㄩㄥ");
  checkEq(&container, &c, "qymf", "ㄑㄩㄥˊ");
  checkEq(&container, &c, "qymj", "ㄑㄩㄥˇ");
  checkEq(&container, &c, "qyml", "ㄑㄩㄥˋ");
  checkEq(&container, &c, "xi", "ㄒㄧ");
  checkEq(&container, &c, "xif", "ㄒㄧˊ");
  checkEq(&container, &c, "xij", "ㄒㄧˇ");
  checkEq(&container, &c, "xil", "ㄒㄧˋ");
  checkEq(&container, &c, "xia", "ㄒㄧㄚ");
  checkEq(&container, &c, "xiaf", "ㄒㄧㄚˊ");
  checkEq(&container, &c, "xiaj", "ㄒㄧㄚˇ");
  checkEq(&container, &c, "xial", "ㄒㄧㄚˋ");
  checkEq(&container, &c, "xie", "ㄒㄧㄝ");
  checkEq(&container, &c, "xief", "ㄒㄧㄝˊ");
  checkEq(&container, &c, "xiej", "ㄒㄧㄝˇ");
  checkEq(&container, &c, "xiel", "ㄒㄧㄝˋ");
  checkEq(&container, &c, "xiw", "ㄒㄧㄠ");
  checkEq(&container, &c, "xiwf", "ㄒㄧㄠˊ");
  checkEq(&container, &c, "xiwj", "ㄒㄧㄠˇ");
  checkEq(&container, &c, "xiwl", "ㄒㄧㄠˋ");
  checkEq(&container, &c, "xiv", "ㄒㄧㄡ");
  checkEq(&container, &c, "xivf", "ㄒㄧㄡˊ");
  checkEq(&container, &c, "xivj", "ㄒㄧㄡˇ");
  checkEq(&container, &c, "xivl", "ㄒㄧㄡˋ");
  checkEq(&container, &c, "xib", "ㄒㄧㄢ");
  checkEq(&container, &c, "xibf", "ㄒㄧㄢˊ");
  checkEq(&container, &c, "xibj", "ㄒㄧㄢˇ");
  checkEq(&container, &c, "xibl", "ㄒㄧㄢˋ");
  checkEq(&container, &c, "xin", "ㄒㄧㄣ");
  checkEq(&container, &c, "xinf", "ㄒㄧㄣˊ");
  checkEq(&container, &c, "xinj", "ㄒㄧㄣˇ");
  checkEq(&container, &c, "xinl", "ㄒㄧㄣˋ");
  checkEq(&container, &c, "xig", "ㄒㄧㄤ");
  checkEq(&container, &c, "xigf", "ㄒㄧㄤˊ");
  checkEq(&container, &c, "xigj", "ㄒㄧㄤˇ");
  checkEq(&container, &c, "xigl", "ㄒㄧㄤˋ");
  checkEq(&container, &c, "xim", "ㄒㄧㄥ");
  checkEq(&container, &c, "ximf", "ㄒㄧㄥˊ");
  checkEq(&container, &c, "ximj", "ㄒㄧㄥˇ");
  checkEq(&container, &c, "ximl", "ㄒㄧㄥˋ");
  checkEq(&container, &c, "xy", "ㄒㄩ");
  checkEq(&container, &c, "xyf", "ㄒㄩˊ");
  checkEq(&container, &c, "xyj", "ㄒㄩˇ");
  checkEq(&container, &c, "xyl", "ㄒㄩˋ");
  checkEq(&container, &c, "xye", "ㄒㄩㄝ");
  checkEq(&container, &c, "xyef", "ㄒㄩㄝˊ");
  checkEq(&container, &c, "xyej", "ㄒㄩㄝˇ");
  checkEq(&container, &c, "xyel", "ㄒㄩㄝˋ");
  checkEq(&container, &c, "xyb", "ㄒㄩㄢ");
  checkEq(&container, &c, "xybf", "ㄒㄩㄢˊ");
  checkEq(&container, &c, "xybj", "ㄒㄩㄢˇ");
  checkEq(&container, &c, "xybl", "ㄒㄩㄢˋ");
  checkEq(&container, &c, "xyn", "ㄒㄩㄣ");
  checkEq(&container, &c, "xynf", "ㄒㄩㄣˊ");
  checkEq(&container, &c, "xynl", "ㄒㄩㄣˋ");
  checkEq(&container, &c, "xym", "ㄒㄩㄥ");
  checkEq(&container, &c, "xymf", "ㄒㄩㄥˊ");
  checkEq(&container, &c, "xymj", "ㄒㄩㄥˇ");
  checkEq(&container, &c, "xyml", "ㄒㄩㄥˋ");
  checkEq(&container, &c, "j", "ㄓ");
  checkEq(&container, &c, "jf", "ㄓˊ");
  checkEq(&container, &c, "jj", "ㄓˇ");
  checkEq(&container, &c, "jl", "ㄓˋ");
  checkEq(&container, &c, "ja", "ㄓㄚ");
  checkEq(&container, &c, "jaf", "ㄓㄚˊ");
  checkEq(&container, &c, "jaj", "ㄓㄚˇ");
  checkEq(&container, &c, "jal", "ㄓㄚˋ");
  checkEq(&container, &c, "je", "ㄓㄜ");
  checkEq(&container, &c, "jef", "ㄓㄜˊ");
  checkEq(&container, &c, "jej", "ㄓㄜˇ");
  checkEq(&container, &c, "jel", "ㄓㄜˋ");
  checkEq(&container, &c, "jed", "ㄓㄜ˙");
  checkEq(&container, &c, "jh", "ㄓㄞ");
  checkEq(&container, &c, "jhf", "ㄓㄞˊ");
  checkEq(&container, &c, "jhj", "ㄓㄞˇ");
  checkEq(&container, &c, "jhl", "ㄓㄞˋ");
  checkEq(&container, &c, "jkl", "ㄓㄟˋ");
  checkEq(&container, &c, "jw", "ㄓㄠ");
  checkEq(&container, &c, "jwf", "ㄓㄠˊ");
  checkEq(&container, &c, "jwj", "ㄓㄠˇ");
  checkEq(&container, &c, "jwl", "ㄓㄠˋ");
  checkEq(&container, &c, "jv", "ㄓㄡ");
  checkEq(&container, &c, "jvf", "ㄓㄡˊ");
  checkEq(&container, &c, "jvj", "ㄓㄡˇ");
  checkEq(&container, &c, "jvl", "ㄓㄡˋ");
  checkEq(&container, &c, "jb", "ㄓㄢ");
  checkEq(&container, &c, "jbj", "ㄓㄢˇ");
  checkEq(&container, &c, "jbl", "ㄓㄢˋ");
  checkEq(&container, &c, "jn", "ㄓㄣ");
  checkEq(&container, &c, "jnf", "ㄓㄣˊ");
  checkEq(&container, &c, "jnj", "ㄓㄣˇ");
  checkEq(&container, &c, "jnl", "ㄓㄣˋ");
  checkEq(&container, &c, "jg", "ㄓㄤ");
  checkEq(&container, &c, "jgj", "ㄓㄤˇ");
  checkEq(&container, &c, "jgl", "ㄓㄤˋ");
  checkEq(&container, &c, "jm", "ㄓㄥ");
  checkEq(&container, &c, "jmj", "ㄓㄥˇ");
  checkEq(&container, &c, "jml", "ㄓㄥˋ");
  checkEq(&container, &c, "ju", "ㄓㄨ");
  checkEq(&container, &c, "juf", "ㄓㄨˊ");
  checkEq(&container, &c, "juj", "ㄓㄨˇ");
  checkEq(&container, &c, "jul", "ㄓㄨˋ");
  checkEq(&container, &c, "jua", "ㄓㄨㄚ");
  checkEq(&container, &c, "juaj", "ㄓㄨㄚˇ");
  checkEq(&container, &c, "juo", "ㄓㄨㄛ");
  checkEq(&container, &c, "juof", "ㄓㄨㄛˊ");
  checkEq(&container, &c, "juol", "ㄓㄨㄛˋ");
  checkEq(&container, &c, "juh", "ㄓㄨㄞ");
  checkEq(&container, &c, "juhj", "ㄓㄨㄞˇ");
  checkEq(&container, &c, "juhl", "ㄓㄨㄞˋ");
  checkEq(&container, &c, "juk", "ㄓㄨㄟ");
  checkEq(&container, &c, "jukj", "ㄓㄨㄟˇ");
  checkEq(&container, &c, "jukl", "ㄓㄨㄟˋ");
  checkEq(&container, &c, "jub", "ㄓㄨㄢ");
  checkEq(&container, &c, "jubj", "ㄓㄨㄢˇ");
  checkEq(&container, &c, "jubl", "ㄓㄨㄢˋ");
  checkEq(&container, &c, "jun", "ㄓㄨㄣ");
  checkEq(&container, &c, "junj", "ㄓㄨㄣˇ");
  checkEq(&container, &c, "junl", "ㄓㄨㄣˋ");
  checkEq(&container, &c, "jug", "ㄓㄨㄤ");
  checkEq(&container, &c, "jugj", "ㄓㄨㄤˇ");
  checkEq(&container, &c, "jugl", "ㄓㄨㄤˋ");
  checkEq(&container, &c, "jum", "ㄓㄨㄥ");
  checkEq(&container, &c, "jumj", "ㄓㄨㄥˇ");
  checkEq(&container, &c, "juml", "ㄓㄨㄥˋ");
  checkEq(&container, &c, "q ", "ㄔ ");
  checkEq(&container, &c, "qf", "ㄔˊ");
  checkEq(&container, &c, "qj", "ㄔˇ");
  checkEq(&container, &c, "ql", "ㄔˋ");
  checkEq(&container, &c, "qa", "ㄔㄚ");
  checkEq(&container, &c, "qaf", "ㄔㄚˊ");
  checkEq(&container, &c, "qaj", "ㄔㄚˇ");
  checkEq(&container, &c, "qal", "ㄔㄚˋ");
  checkEq(&container, &c, "qe", "ㄔㄜ");
  checkEq(&container, &c, "qej", "ㄔㄜˇ");
  checkEq(&container, &c, "qel", "ㄔㄜˋ");
  checkEq(&container, &c, "qh", "ㄔㄞ");
  checkEq(&container, &c, "qhf", "ㄔㄞˊ");
  checkEq(&container, &c, "qhj", "ㄔㄞˇ");
  checkEq(&container, &c, "qhl", "ㄔㄞˋ");
  checkEq(&container, &c, "qw", "ㄔㄠ");
  checkEq(&container, &c, "qwf", "ㄔㄠˊ");
  checkEq(&container, &c, "qwj", "ㄔㄠˇ");
  checkEq(&container, &c, "qwl", "ㄔㄠˋ");
  checkEq(&container, &c, "qv", "ㄔㄡ");
  checkEq(&container, &c, "qvf", "ㄔㄡˊ");
  checkEq(&container, &c, "qvj", "ㄔㄡˇ");
  checkEq(&container, &c, "qvl", "ㄔㄡˋ");
  checkEq(&container, &c, "qb", "ㄔㄢ");
  checkEq(&container, &c, "qbf", "ㄔㄢˊ");
  checkEq(&container, &c, "qbj", "ㄔㄢˇ");
  checkEq(&container, &c, "qbl", "ㄔㄢˋ");
  checkEq(&container, &c, "qn", "ㄔㄣ");
  checkEq(&container, &c, "qnf", "ㄔㄣˊ");
  checkEq(&container, &c, "qnj", "ㄔㄣˇ");
  checkEq(&container, &c, "qnl", "ㄔㄣˋ");
  checkEq(&container, &c, "qnd", "ㄔㄣ˙");
  checkEq(&container, &c, "qg", "ㄔㄤ");
  checkEq(&container, &c, "qgf", "ㄔㄤˊ");
  checkEq(&container, &c, "qgj", "ㄔㄤˇ");
  checkEq(&container, &c, "qgl", "ㄔㄤˋ");
  checkEq(&container, &c, "qm", "ㄔㄥ");
  checkEq(&container, &c, "qmf", "ㄔㄥˊ");
  checkEq(&container, &c, "qmj", "ㄔㄥˇ");
  checkEq(&container, &c, "qml", "ㄔㄥˋ");
  checkEq(&container, &c, "qu", "ㄔㄨ");
  checkEq(&container, &c, "quf", "ㄔㄨˊ");
  checkEq(&container, &c, "quj", "ㄔㄨˇ");
  checkEq(&container, &c, "qul", "ㄔㄨˋ");
  checkEq(&container, &c, "qua", "ㄔㄨㄚ");
  checkEq(&container, &c, "quaj", "ㄔㄨㄚˇ");
  checkEq(&container, &c, "qual", "ㄔㄨㄚˋ");
  checkEq(&container, &c, "quo", "ㄔㄨㄛ");
  checkEq(&container, &c, "quol", "ㄔㄨㄛˋ");
  checkEq(&container, &c, "quh", "ㄔㄨㄞ");
  checkEq(&container, &c, "quhf", "ㄔㄨㄞˊ");
  checkEq(&container, &c, "quhj", "ㄔㄨㄞˇ");
  checkEq(&container, &c, "quhl", "ㄔㄨㄞˋ");
  checkEq(&container, &c, "quk", "ㄔㄨㄟ");
  checkEq(&container, &c, "qukf", "ㄔㄨㄟˊ");
  checkEq(&container, &c, "qukj", "ㄔㄨㄟˇ");
  checkEq(&container, &c, "qukl", "ㄔㄨㄟˋ");
  checkEq(&container, &c, "qub", "ㄔㄨㄢ");
  checkEq(&container, &c, "qubf", "ㄔㄨㄢˊ");
  checkEq(&container, &c, "qubj", "ㄔㄨㄢˇ");
  checkEq(&container, &c, "qubl", "ㄔㄨㄢˋ");
  checkEq(&container, &c, "qun", "ㄔㄨㄣ");
  checkEq(&container, &c, "qunf", "ㄔㄨㄣˊ");
  checkEq(&container, &c, "qunj", "ㄔㄨㄣˇ");
  checkEq(&container, &c, "qug", "ㄔㄨㄤ");
  checkEq(&container, &c, "qugf", "ㄔㄨㄤˊ");
  checkEq(&container, &c, "qugj", "ㄔㄨㄤˇ");
  checkEq(&container, &c, "qugl", "ㄔㄨㄤˋ");
  checkEq(&container, &c, "qum", "ㄔㄨㄥ");
  checkEq(&container, &c, "qumf", "ㄔㄨㄥˊ");
  checkEq(&container, &c, "qumj", "ㄔㄨㄥˇ");
  checkEq(&container, &c, "quml", "ㄔㄨㄥˋ");
  checkEq(&container, &c, "x ", "ㄕ ");
  checkEq(&container, &c, "xf", "ㄕˊ");
  checkEq(&container, &c, "xj", "ㄕˇ");
  checkEq(&container, &c, "xl", "ㄕˋ");
  checkEq(&container, &c, "xd", "ㄕ˙");
  checkEq(&container, &c, "xa", "ㄕㄚ");
  checkEq(&container, &c, "xaf", "ㄕㄚˊ");
  checkEq(&container, &c, "xaj", "ㄕㄚˇ");
  checkEq(&container, &c, "xal", "ㄕㄚˋ");
  checkEq(&container, &c, "xad", "ㄕㄚ˙");
  checkEq(&container, &c, "xe", "ㄕㄜ");
  checkEq(&container, &c, "xef", "ㄕㄜˊ");
  checkEq(&container, &c, "xej", "ㄕㄜˇ");
  checkEq(&container, &c, "xel", "ㄕㄜˋ");
  checkEq(&container, &c, "xh", "ㄕㄞ");
  checkEq(&container, &c, "xhj", "ㄕㄞˇ");
  checkEq(&container, &c, "xhl", "ㄕㄞˋ");
  checkEq(&container, &c, "xkf", "ㄕㄟˊ");
  checkEq(&container, &c, "xw", "ㄕㄠ");
  checkEq(&container, &c, "xwf", "ㄕㄠˊ");
  checkEq(&container, &c, "xwj", "ㄕㄠˇ");
  checkEq(&container, &c, "xwl", "ㄕㄠˋ");
  checkEq(&container, &c, "xv", "ㄕㄡ");
  checkEq(&container, &c, "xvf", "ㄕㄡˊ");
  checkEq(&container, &c, "xvj", "ㄕㄡˇ");
  checkEq(&container, &c, "xvl", "ㄕㄡˋ");
  checkEq(&container, &c, "xb", "ㄕㄢ");
  checkEq(&container, &c, "xbf", "ㄕㄢˊ");
  checkEq(&container, &c, "xbj", "ㄕㄢˇ");
  checkEq(&container, &c, "xbl", "ㄕㄢˋ");
  checkEq(&container, &c, "xn", "ㄕㄣ");
  checkEq(&container, &c, "xnf", "ㄕㄣˊ");
  checkEq(&container, &c, "xnj", "ㄕㄣˇ");
  checkEq(&container, &c, "xnl", "ㄕㄣˋ");
  checkEq(&container, &c, "xg", "ㄕㄤ");
  checkEq(&container, &c, "xgj", "ㄕㄤˇ");
  checkEq(&container, &c, "xgl", "ㄕㄤˋ");
  checkEq(&container, &c, "xgd", "ㄕㄤ˙");
  checkEq(&container, &c, "xm", "ㄕㄥ");
  checkEq(&container, &c, "xmf", "ㄕㄥˊ");
  checkEq(&container, &c, "xmj", "ㄕㄥˇ");
  checkEq(&container, &c, "xml", "ㄕㄥˋ");
  checkEq(&container, &c, "xu", "ㄕㄨ");
  checkEq(&container, &c, "xuf", "ㄕㄨˊ");
  checkEq(&container, &c, "xuj", "ㄕㄨˇ");
  checkEq(&container, &c, "xul", "ㄕㄨˋ");
  checkEq(&container, &c, "xua", "ㄕㄨㄚ");
  checkEq(&container, &c, "xuaj", "ㄕㄨㄚˇ");
  checkEq(&container, &c, "xual", "ㄕㄨㄚˋ");
  checkEq(&container, &c, "xuo", "ㄕㄨㄛ");
  checkEq(&container, &c, "xuol", "ㄕㄨㄛˋ");
  checkEq(&container, &c, "xuh", "ㄕㄨㄞ");
  checkEq(&container, &c, "xuhj", "ㄕㄨㄞˇ");
  checkEq(&container, &c, "xuhl", "ㄕㄨㄞˋ");
  checkEq(&container, &c, "xuk", "ㄕㄨㄟ");
  checkEq(&container, &c, "xukf", "ㄕㄨㄟˊ");
  checkEq(&container, &c, "xukj", "ㄕㄨㄟˇ");
  checkEq(&container, &c, "xukl", "ㄕㄨㄟˋ");
  checkEq(&container, &c, "xub", "ㄕㄨㄢ");
  checkEq(&container, &c, "xubl", "ㄕㄨㄢˋ");
  checkEq(&container, &c, "xunj", "ㄕㄨㄣˇ");
  checkEq(&container, &c, "xunl", "ㄕㄨㄣˋ");
  checkEq(&container, &c, "xug", "ㄕㄨㄤ");
  checkEq(&container, &c, "xugf", "ㄕㄨㄤˊ");
  checkEq(&container, &c, "xugj", "ㄕㄨㄤˇ");
  checkEq(&container, &c, "xugl", "ㄕㄨㄤˋ");
  checkEq(&container, &c, "rl", "ㄖˋ");
  checkEq(&container, &c, "rej", "ㄖㄜˇ");
  checkEq(&container, &c, "rel", "ㄖㄜˋ");
  checkEq(&container, &c, "rwf", "ㄖㄠˊ");
  checkEq(&container, &c, "rwj", "ㄖㄠˇ");
  checkEq(&container, &c, "rwl", "ㄖㄠˋ");
  checkEq(&container, &c, "rvf", "ㄖㄡˊ");
  checkEq(&container, &c, "rvj", "ㄖㄡˇ");
  checkEq(&container, &c, "rvl", "ㄖㄡˋ");
  checkEq(&container, &c, "rbf", "ㄖㄢˊ");
  checkEq(&container, &c, "rbj", "ㄖㄢˇ");
  checkEq(&container, &c, "rbl", "ㄖㄢˋ");
  checkEq(&container, &c, "rnf", "ㄖㄣˊ");
  checkEq(&container, &c, "rnj", "ㄖㄣˇ");
  checkEq(&container, &c, "rnl", "ㄖㄣˋ");
  checkEq(&container, &c, "rg", "ㄖㄤ");
  checkEq(&container, &c, "rgf", "ㄖㄤˊ");
  checkEq(&container, &c, "rgj", "ㄖㄤˇ");
  checkEq(&container, &c, "rgl", "ㄖㄤˋ");
  checkEq(&container, &c, "rm", "ㄖㄥ");
  checkEq(&container, &c, "rmf", "ㄖㄥˊ");
  checkEq(&container, &c, "rmj", "ㄖㄥˇ");
  checkEq(&container, &c, "rml", "ㄖㄥˋ");
  checkEq(&container, &c, "ruf", "ㄖㄨˊ");
  checkEq(&container, &c, "ruj", "ㄖㄨˇ");
  checkEq(&container, &c, "rul", "ㄖㄨˋ");
  checkEq(&container, &c, "ruof", "ㄖㄨㄛˊ");
  checkEq(&container, &c, "ruol", "ㄖㄨㄛˋ");
  checkEq(&container, &c, "rukf", "ㄖㄨㄟˊ");
  checkEq(&container, &c, "rukj", "ㄖㄨㄟˇ");
  checkEq(&container, &c, "rukl", "ㄖㄨㄟˋ");
  checkEq(&container, &c, "rubf", "ㄖㄨㄢˊ");
  checkEq(&container, &c, "rubj", "ㄖㄨㄢˇ");
  checkEq(&container, &c, "rubl", "ㄖㄨㄢˋ");
  checkEq(&container, &c, "runf", "ㄖㄨㄣˊ");
  checkEq(&container, &c, "runj", "ㄖㄨㄣˇ");
  checkEq(&container, &c, "runl", "ㄖㄨㄣˋ");
  checkEq(&container, &c, "rumf", "ㄖㄨㄥˊ");
  checkEq(&container, &c, "rumj", "ㄖㄨㄥˇ");
  checkEq(&container, &c, "ruml", "ㄖㄨㄥˋ");
  checkEq(&container, &c, "z", "ㄗ");
  checkEq(&container, &c, "zf", "ㄗˊ");
  checkEq(&container, &c, "zj", "ㄗˇ");
  checkEq(&container, &c, "zl", "ㄗˋ");
  checkEq(&container, &c, "zd", "ㄗ˙");
  checkEq(&container, &c, "za", "ㄗㄚ");
  checkEq(&container, &c, "zaf", "ㄗㄚˊ");
  checkEq(&container, &c, "zaj", "ㄗㄚˇ");
  checkEq(&container, &c, "zef", "ㄗㄜˊ");
  checkEq(&container, &c, "zej", "ㄗㄜˇ");
  checkEq(&container, &c, "zel", "ㄗㄜˋ");
  checkEq(&container, &c, "zh", "ㄗㄞ");
  checkEq(&container, &c, "zhj", "ㄗㄞˇ");
  checkEq(&container, &c, "zhl", "ㄗㄞˋ");
  checkEq(&container, &c, "zkf", "ㄗㄟˊ");
  checkEq(&container, &c, "zw", "ㄗㄠ");
  checkEq(&container, &c, "zwf", "ㄗㄠˊ");
  checkEq(&container, &c, "zwj", "ㄗㄠˇ");
  checkEq(&container, &c, "zwl", "ㄗㄠˋ");
  checkEq(&container, &c, "zv", "ㄗㄡ");
  checkEq(&container, &c, "zvj", "ㄗㄡˇ");
  checkEq(&container, &c, "zvl", "ㄗㄡˋ");
  checkEq(&container, &c, "zb", "ㄗㄢ");
  checkEq(&container, &c, "zbf", "ㄗㄢˊ");
  checkEq(&container, &c, "zbj", "ㄗㄢˇ");
  checkEq(&container, &c, "zbl", "ㄗㄢˋ");
  checkEq(&container, &c, "zn", "ㄗㄣ");
  checkEq(&container, &c, "znj", "ㄗㄣˇ");
  checkEq(&container, &c, "znl", "ㄗㄣˋ");
  checkEq(&container, &c, "zg", "ㄗㄤ");
  checkEq(&container, &c, "zgj", "ㄗㄤˇ");
  checkEq(&container, &c, "zgl", "ㄗㄤˋ");
  checkEq(&container, &c, "zm", "ㄗㄥ");
  checkEq(&container, &c, "zmj", "ㄗㄥˇ");
  checkEq(&container, &c, "zml", "ㄗㄥˋ");
  checkEq(&container, &c, "zu", "ㄗㄨ");
  checkEq(&container, &c, "zuf", "ㄗㄨˊ");
  checkEq(&container, &c, "zuj", "ㄗㄨˇ");
  checkEq(&container, &c, "zul", "ㄗㄨˋ");
  checkEq(&container, &c, "zuo", "ㄗㄨㄛ");
  checkEq(&container, &c, "zuof", "ㄗㄨㄛˊ");
  checkEq(&container, &c, "zuoj", "ㄗㄨㄛˇ");
  checkEq(&container, &c, "zuol", "ㄗㄨㄛˋ");
  checkEq(&container, &c, "zuod", "ㄗㄨㄛ˙");
  checkEq(&container, &c, "zuk", "ㄗㄨㄟ");
  checkEq(&container, &c, "zukj", "ㄗㄨㄟˇ");
  checkEq(&container, &c, "zukl", "ㄗㄨㄟˋ");
  checkEq(&container, &c, "zub", "ㄗㄨㄢ");
  checkEq(&container, &c, "zubj", "ㄗㄨㄢˇ");
  checkEq(&container, &c, "zubl", "ㄗㄨㄢˋ");
  checkEq(&container, &c, "zun", "ㄗㄨㄣ");
  checkEq(&container, &c, "zunj", "ㄗㄨㄣˇ");
  checkEq(&container, &c, "zunl", "ㄗㄨㄣˋ");
  checkEq(&container, &c, "zum", "ㄗㄨㄥ");
  checkEq(&container, &c, "zumj", "ㄗㄨㄥˇ");
  checkEq(&container, &c, "zuml", "ㄗㄨㄥˋ");
  checkEq(&container, &c, "c", "ㄘ");
  checkEq(&container, &c, "cf", "ㄘˊ");
  checkEq(&container, &c, "cj", "ㄘˇ");
  checkEq(&container, &c, "cl", "ㄘˋ");
  checkEq(&container, &c, "ca", "ㄘㄚ");
  checkEq(&container, &c, "caj", "ㄘㄚˇ");
  checkEq(&container, &c, "cal", "ㄘㄚˋ");
  checkEq(&container, &c, "cel", "ㄘㄜˋ");
  checkEq(&container, &c, "ch", "ㄘㄞ");
  checkEq(&container, &c, "chf", "ㄘㄞˊ");
  checkEq(&container, &c, "chj", "ㄘㄞˇ");
  checkEq(&container, &c, "chl", "ㄘㄞˋ");
  checkEq(&container, &c, "cw", "ㄘㄠ");
  checkEq(&container, &c, "cwf", "ㄘㄠˊ");
  checkEq(&container, &c, "cwj", "ㄘㄠˇ");
  checkEq(&container, &c, "cwl", "ㄘㄠˋ");
  checkEq(&container, &c, "cv", "ㄘㄡ");
  checkEq(&container, &c, "cvf", "ㄘㄡˊ");
  checkEq(&container, &c, "cvj", "ㄘㄡˇ");
  checkEq(&container, &c, "cvl", "ㄘㄡˋ");
  checkEq(&container, &c, "cb", "ㄘㄢ");
  checkEq(&container, &c, "cbf", "ㄘㄢˊ");
  checkEq(&container, &c, "cbj", "ㄘㄢˇ");
  checkEq(&container, &c, "cbl", "ㄘㄢˋ");
  checkEq(&container, &c, "cn", "ㄘㄣ");
  checkEq(&container, &c, "cnf", "ㄘㄣˊ");
  checkEq(&container, &c, "cg", "ㄘㄤ");
  checkEq(&container, &c, "cgf", "ㄘㄤˊ");
  checkEq(&container, &c, "cgj", "ㄘㄤˇ");
  checkEq(&container, &c, "cgl", "ㄘㄤˋ");
  checkEq(&container, &c, "cm", "ㄘㄥ");
  checkEq(&container, &c, "cmf", "ㄘㄥˊ");
  checkEq(&container, &c, "cmj", "ㄘㄥˇ");
  checkEq(&container, &c, "cml", "ㄘㄥˋ");
  checkEq(&container, &c, "cu", "ㄘㄨ");
  checkEq(&container, &c, "cuf", "ㄘㄨˊ");
  checkEq(&container, &c, "cuj", "ㄘㄨˇ");
  checkEq(&container, &c, "cul", "ㄘㄨˋ");
  checkEq(&container, &c, "cuo", "ㄘㄨㄛ");
  checkEq(&container, &c, "cuof", "ㄘㄨㄛˊ");
  checkEq(&container, &c, "cuoj", "ㄘㄨㄛˇ");
  checkEq(&container, &c, "cuol", "ㄘㄨㄛˋ");
  checkEq(&container, &c, "cuk", "ㄘㄨㄟ");
  checkEq(&container, &c, "cukj", "ㄘㄨㄟˇ");
  checkEq(&container, &c, "cukl", "ㄘㄨㄟˋ");
  checkEq(&container, &c, "cub", "ㄘㄨㄢ");
  checkEq(&container, &c, "cubf", "ㄘㄨㄢˊ");
  checkEq(&container, &c, "cubj", "ㄘㄨㄢˇ");
  checkEq(&container, &c, "cubl", "ㄘㄨㄢˋ");
  checkEq(&container, &c, "cun", "ㄘㄨㄣ");
  checkEq(&container, &c, "cunf", "ㄘㄨㄣˊ");
  checkEq(&container, &c, "cunj", "ㄘㄨㄣˇ");
  checkEq(&container, &c, "cunl", "ㄘㄨㄣˋ");
  checkEq(&container, &c, "cum", "ㄘㄨㄥ");
  checkEq(&container, &c, "cumf", "ㄘㄨㄥˊ");
  checkEq(&container, &c, "cumj", "ㄘㄨㄥˇ");
  checkEq(&container, &c, "cuml", "ㄘㄨㄥˋ");
  checkEq(&container, &c, "s", "ㄙ");
  checkEq(&container, &c, "sj", "ㄙˇ");
  checkEq(&container, &c, "sl", "ㄙˋ");
  checkEq(&container, &c, "sa", "ㄙㄚ");
  checkEq(&container, &c, "saj", "ㄙㄚˇ");
  checkEq(&container, &c, "sal", "ㄙㄚˋ");
  checkEq(&container, &c, "sad", "ㄙㄚ˙");
  checkEq(&container, &c, "se", "ㄙㄜ");
  checkEq(&container, &c, "sel", "ㄙㄜˋ");
  checkEq(&container, &c, "sh", "ㄙㄞ");
  checkEq(&container, &c, "shf", "ㄙㄞˊ");
  checkEq(&container, &c, "shj", "ㄙㄞˇ");
  checkEq(&container, &c, "shl", "ㄙㄞˋ");
  checkEq(&container, &c, "sk", "ㄙㄟ");
  checkEq(&container, &c, "sw", "ㄙㄠ");
  checkEq(&container, &c, "swj", "ㄙㄠˇ");
  checkEq(&container, &c, "swl", "ㄙㄠˋ");
  checkEq(&container, &c, "sv", "ㄙㄡ");
  checkEq(&container, &c, "svj", "ㄙㄡˇ");
  checkEq(&container, &c, "svl", "ㄙㄡˋ");
  checkEq(&container, &c, "sb", "ㄙㄢ");
  checkEq(&container, &c, "sbj", "ㄙㄢˇ");
  checkEq(&container, &c, "sbl", "ㄙㄢˋ");
  checkEq(&container, &c, "sn", "ㄙㄣ");
  checkEq(&container, &c, "snj", "ㄙㄣˇ");
  checkEq(&container, &c, "sg", "ㄙㄤ");
  checkEq(&container, &c, "sgj", "ㄙㄤˇ");
  checkEq(&container, &c, "sgl", "ㄙㄤˋ");
  checkEq(&container, &c, "sm", "ㄙㄥ");
  checkEq(&container, &c, "sml", "ㄙㄥˋ");
  checkEq(&container, &c, "su", "ㄙㄨ");
  checkEq(&container, &c, "suf", "ㄙㄨˊ");
  checkEq(&container, &c, "suj", "ㄙㄨˇ");
  checkEq(&container, &c, "sul", "ㄙㄨˋ");
  checkEq(&container, &c, "suo", "ㄙㄨㄛ");
  checkEq(&container, &c, "suof", "ㄙㄨㄛˊ");
  checkEq(&container, &c, "suoj", "ㄙㄨㄛˇ");
  checkEq(&container, &c, "suol", "ㄙㄨㄛˋ");
  checkEq(&container, &c, "suk", "ㄙㄨㄟ");
  checkEq(&container, &c, "sukf", "ㄙㄨㄟˊ");
  checkEq(&container, &c, "sukj", "ㄙㄨㄟˇ");
  checkEq(&container, &c, "sukl", "ㄙㄨㄟˋ");
  checkEq(&container, &c, "sub", "ㄙㄨㄢ");
  checkEq(&container, &c, "subj", "ㄙㄨㄢˇ");
  checkEq(&container, &c, "subl", "ㄙㄨㄢˋ");
  checkEq(&container, &c, "sun", "ㄙㄨㄣ");
  checkEq(&container, &c, "sunj", "ㄙㄨㄣˇ");
  checkEq(&container, &c, "sunl", "ㄙㄨㄣˋ");
  checkEq(&container, &c, "sum", "ㄙㄨㄥ");
  checkEq(&container, &c, "sumf", "ㄙㄨㄥˊ");
  checkEq(&container, &c, "sumj", "ㄙㄨㄥˇ");
  checkEq(&container, &c, "suml", "ㄙㄨㄥˋ");
  checkEq(&container, &c, "a", "ㄚ");
  checkEq(&container, &c, "af", "ㄚˊ");
  checkEq(&container, &c, "al", "ㄚˋ");
  checkEq(&container, &c, "ad", "ㄚ˙");
  checkEq(&container, &c, "o", "ㄛ");
  checkEq(&container, &c, "of", "ㄛˊ");
  checkEq(&container, &c, "oj", "ㄛˇ");
  checkEq(&container, &c, "ol", "ㄛˋ");
  checkEq(&container, &c, "e", "ㄜ");
  checkEq(&container, &c, "ef", "ㄜˊ");
  checkEq(&container, &c, "ej", "ㄜˇ");
  checkEq(&container, &c, "el", "ㄜˋ");
  // checkEq(&container, &c, "ef", "ㄝˊ");
  // checkEq(&container, &c, "ej", "ㄝˇ");
  // checkEq(&container, &c, "el", "ㄝˋ");
  // checkEq(&container, &c, "ed", "ㄝ˙");
  // checkEq(&container, &c, "h", "ㄞ");
  checkEq(&container, &c, "hf", "ㄞˊ");
  checkEq(&container, &c, "hj", "ㄞˇ");
  checkEq(&container, &c, "hl", "ㄞˋ");
  checkEq(&container, &c, "kl", "ㄟˋ");
  checkEq(&container, &c, "w", "ㄠ");
  checkEq(&container, &c, "wf", "ㄠˊ");
  checkEq(&container, &c, "wj", "ㄠˇ");
  checkEq(&container, &c, "wl", "ㄠˋ");
  checkEq(&container, &c, "v", "ㄡ");
  checkEq(&container, &c, "vf", "ㄡˊ");
  checkEq(&container, &c, "vj", "ㄡˇ");
  checkEq(&container, &c, "vl", "ㄡˋ");
  checkEq(&container, &c, "vd", "ㄡ˙");
  checkEq(&container, &c, "b ", "ㄢ ");
  checkEq(&container, &c, "bf", "ㄢˊ");
  checkEq(&container, &c, "bj", "ㄢˇ");
  checkEq(&container, &c, "bl", "ㄢˋ");
  checkEq(&container, &c, "n ", "ㄣ ");
  checkEq(&container, &c, "nf", "ㄣˊ");
  checkEq(&container, &c, "nj", "ㄣˇ");
  checkEq(&container, &c, "nl", "ㄣˋ");
  checkEq(&container, &c, "nd", "ㄣ˙");
  checkEq(&container, &c, "g ", "ㄤ ");
  checkEq(&container, &c, "gf", "ㄤˊ");
  checkEq(&container, &c, "gj", "ㄤˇ");
  checkEq(&container, &c, "gl", "ㄤˋ");
  checkEq(&container, &c, "m ", "ㄥ ");
  checkEq(&container, &c, "ml", "ㄥˋ");
  checkEq(&container, &c, "l ", "ㄦ ");
  checkEq(&container, &c, "lf", "ㄦˊ");
  checkEq(&container, &c, "lj", "ㄦˇ");
  checkEq(&container, &c, "ll", "ㄦˋ");
  checkEq(&container, &c, "ld", "ㄦ˙");
  checkEq(&container, &c, "i", "ㄧ");
  checkEq(&container, &c, "if", "ㄧˊ");
  checkEq(&container, &c, "ij", "ㄧˇ");
  checkEq(&container, &c, "il", "ㄧˋ");
  checkEq(&container, &c, "ia", "ㄧㄚ");
  checkEq(&container, &c, "iaf", "ㄧㄚˊ");
  checkEq(&container, &c, "iaj", "ㄧㄚˇ");
  checkEq(&container, &c, "ial", "ㄧㄚˋ");
  checkEq(&container, &c, "iad", "ㄧㄚ˙");
  checkEq(&container, &c, "io", "ㄧㄛ");
  checkEq(&container, &c, "iod", "ㄧㄛ˙");
  checkEq(&container, &c, "ie", "ㄧㄝ");
  checkEq(&container, &c, "ief", "ㄧㄝˊ");
  checkEq(&container, &c, "iej", "ㄧㄝˇ");
  checkEq(&container, &c, "iel", "ㄧㄝˋ");
  checkEq(&container, &c, "ied", "ㄧㄝ˙");
  checkEq(&container, &c, "ihf", "ㄧㄞˊ");
  checkEq(&container, &c, "iw", "ㄧㄠ");
  checkEq(&container, &c, "iwf", "ㄧㄠˊ");
  checkEq(&container, &c, "iwj", "ㄧㄠˇ");
  checkEq(&container, &c, "iwl", "ㄧㄠˋ");
  checkEq(&container, &c, "iv", "ㄧㄡ");
  checkEq(&container, &c, "ivf", "ㄧㄡˊ");
  checkEq(&container, &c, "ivj", "ㄧㄡˇ");
  checkEq(&container, &c, "ivl", "ㄧㄡˋ");
  checkEq(&container, &c, "ib", "ㄧㄢ");
  checkEq(&container, &c, "ibf", "ㄧㄢˊ");
  checkEq(&container, &c, "ibj", "ㄧㄢˇ");
  checkEq(&container, &c, "ibl", "ㄧㄢˋ");
  checkEq(&container, &c, "in", "ㄧㄣ");
  checkEq(&container, &c, "inf", "ㄧㄣˊ");
  checkEq(&container, &c, "inj", "ㄧㄣˇ");
  checkEq(&container, &c, "inl", "ㄧㄣˋ");
  checkEq(&container, &c, "ig", "ㄧㄤ");
  checkEq(&container, &c, "igf", "ㄧㄤˊ");
  checkEq(&container, &c, "igj", "ㄧㄤˇ");
  checkEq(&container, &c, "igl", "ㄧㄤˋ");
  checkEq(&container, &c, "im", "ㄧㄥ");
  checkEq(&container, &c, "imf", "ㄧㄥˊ");
  checkEq(&container, &c, "imj", "ㄧㄥˇ");
  checkEq(&container, &c, "iml", "ㄧㄥˋ");
  checkEq(&container, &c, "u", "ㄨ");
  checkEq(&container, &c, "uf", "ㄨˊ");
  checkEq(&container, &c, "uj", "ㄨˇ");
  checkEq(&container, &c, "ul", "ㄨˋ");
  checkEq(&container, &c, "ua", "ㄨㄚ");
  checkEq(&container, &c, "uaf", "ㄨㄚˊ");
  checkEq(&container, &c, "uaj", "ㄨㄚˇ");
  checkEq(&container, &c, "ual", "ㄨㄚˋ");
  checkEq(&container, &c, "uad", "ㄨㄚ˙");
  checkEq(&container, &c, "uo", "ㄨㄛ");
  checkEq(&container, &c, "uoj", "ㄨㄛˇ");
  checkEq(&container, &c, "uol", "ㄨㄛˋ");
  checkEq(&container, &c, "uh", "ㄨㄞ");
  checkEq(&container, &c, "uhj", "ㄨㄞˇ");
  checkEq(&container, &c, "uhl", "ㄨㄞˋ");
  checkEq(&container, &c, "uk", "ㄨㄟ");
  checkEq(&container, &c, "ukf", "ㄨㄟˊ");
  checkEq(&container, &c, "ukj", "ㄨㄟˇ");
  checkEq(&container, &c, "ukl", "ㄨㄟˋ");
  checkEq(&container, &c, "ub", "ㄨㄢ");
  checkEq(&container, &c, "ubf", "ㄨㄢˊ");
  checkEq(&container, &c, "ubj", "ㄨㄢˇ");
  checkEq(&container, &c, "ubl", "ㄨㄢˋ");
  checkEq(&container, &c, "un", "ㄨㄣ");
  checkEq(&container, &c, "unf", "ㄨㄣˊ");
  checkEq(&container, &c, "unj", "ㄨㄣˇ");
  checkEq(&container, &c, "unl", "ㄨㄣˋ");
  checkEq(&container, &c, "ug", "ㄨㄤ");
  checkEq(&container, &c, "ugf", "ㄨㄤˊ");
  checkEq(&container, &c, "ugj", "ㄨㄤˇ");
  checkEq(&container, &c, "ugl", "ㄨㄤˋ");
  checkEq(&container, &c, "um", "ㄨㄥ");
  checkEq(&container, &c, "umj", "ㄨㄥˇ");
  checkEq(&container, &c, "uml", "ㄨㄥˋ");
  checkEq(&container, &c, "y", "ㄩ");
  checkEq(&container, &c, "yf", "ㄩˊ");
  checkEq(&container, &c, "yj", "ㄩˇ");
  checkEq(&container, &c, "yl", "ㄩˋ");
  checkEq(&container, &c, "ye", "ㄩㄝ");
  checkEq(&container, &c, "yej", "ㄩㄝˇ");
  checkEq(&container, &c, "yel", "ㄩㄝˋ");
  checkEq(&container, &c, "yb", "ㄩㄢ");
  checkEq(&container, &c, "ybf", "ㄩㄢˊ");
  checkEq(&container, &c, "ybj", "ㄩㄢˇ");
  checkEq(&container, &c, "ybl", "ㄩㄢˋ");
  checkEq(&container, &c, "yn", "ㄩㄣ");
  checkEq(&container, &c, "ynf", "ㄩㄣˊ");
  checkEq(&container, &c, "ynj", "ㄩㄣˇ");
  checkEq(&container, &c, "ynl", "ㄩㄣˋ");
  checkEq(&container, &c, "ym", "ㄩㄥ");
  checkEq(&container, &c, "ymf", "ㄩㄥˊ");
  checkEq(&container, &c, "ymj", "ㄩㄥˇ");
  checkEq(&container, &c, "yml", "ㄩㄥˋ");
  checkEq(&container, &c, "bic", "ㄅㄧㄝ");
  checkEq(&container, &c, "bicf", "ㄅㄧㄝˊ");
  checkEq(&container, &c, "bicj", "ㄅㄧㄝˇ");
  checkEq(&container, &c, "bicl", "ㄅㄧㄝˋ");
  checkEq(&container, &c, "pic", "ㄆㄧㄝ");
  checkEq(&container, &c, "picj", "ㄆㄧㄝˇ");
  checkEq(&container, &c, "picl", "ㄆㄧㄝˋ");
  checkEq(&container, &c, "mic", "ㄇㄧㄝ");
  checkEq(&container, &c, "micf", "ㄇㄧㄝˊ");
  checkEq(&container, &c, "micl", "ㄇㄧㄝˋ");
  checkEq(&container, &c, "dic", "ㄉㄧㄝ");
  checkEq(&container, &c, "dicf", "ㄉㄧㄝˊ");
  checkEq(&container, &c, "dicj", "ㄉㄧㄝˇ");
  checkEq(&container, &c, "dicl", "ㄉㄧㄝˋ");
  checkEq(&container, &c, "tic", "ㄊㄧㄝ");
  checkEq(&container, &c, "ticf", "ㄊㄧㄝˊ");
  checkEq(&container, &c, "ticj", "ㄊㄧㄝˇ");
  checkEq(&container, &c, "ticl", "ㄊㄧㄝˋ");
  checkEq(&container, &c, "nic", "ㄋㄧㄝ");
  checkEq(&container, &c, "nicf", "ㄋㄧㄝˊ");
  checkEq(&container, &c, "nicl", "ㄋㄧㄝˋ");
  checkEq(&container, &c, "nycl", "ㄋㄩㄝˋ");
  checkEq(&container, &c, "lic", "ㄌㄧㄝ");
  checkEq(&container, &c, "licf", "ㄌㄧㄝˊ");
  checkEq(&container, &c, "licj", "ㄌㄧㄝˇ");
  checkEq(&container, &c, "licl", "ㄌㄧㄝˋ");
  checkEq(&container, &c, "lyc", "ㄌㄩㄝ");
  checkEq(&container, &c, "lycj", "ㄌㄩㄝˇ");
  checkEq(&container, &c, "lycl", "ㄌㄩㄝˋ");
  checkEq(&container, &c, "jic", "ㄐㄧㄝ");
  checkEq(&container, &c, "jicf", "ㄐㄧㄝˊ");
  checkEq(&container, &c, "jicj", "ㄐㄧㄝˇ");
  checkEq(&container, &c, "jicl", "ㄐㄧㄝˋ");
  checkEq(&container, &c, "jicd", "ㄐㄧㄝ˙");
  checkEq(&container, &c, "jyc", "ㄐㄩㄝ");
  checkEq(&container, &c, "jycf", "ㄐㄩㄝˊ");
  checkEq(&container, &c, "jycj", "ㄐㄩㄝˇ");
  checkEq(&container, &c, "jycl", "ㄐㄩㄝˋ");
  checkEq(&container, &c, "qic", "ㄑㄧㄝ");
  checkEq(&container, &c, "qicf", "ㄑㄧㄝˊ");
  checkEq(&container, &c, "qicj", "ㄑㄧㄝˇ");
  checkEq(&container, &c, "qicl", "ㄑㄧㄝˋ");
  checkEq(&container, &c, "qyc", "ㄑㄩㄝ");
  checkEq(&container, &c, "qycf", "ㄑㄩㄝˊ");
  checkEq(&container, &c, "qycl", "ㄑㄩㄝˋ");
  checkEq(&container, &c, "xic", "ㄒㄧㄝ");
  checkEq(&container, &c, "xicf", "ㄒㄧㄝˊ");
  checkEq(&container, &c, "xicj", "ㄒㄧㄝˇ");
  checkEq(&container, &c, "xicl", "ㄒㄧㄝˋ");
  checkEq(&container, &c, "xyc", "ㄒㄩㄝ");
  checkEq(&container, &c, "xycf", "ㄒㄩㄝˊ");
  checkEq(&container, &c, "xycj", "ㄒㄩㄝˇ");
  checkEq(&container, &c, "xycl", "ㄒㄩㄝˋ");
  // checkEq(&container, &c, "cf", "ㄝˊ");
  // checkEq(&container, &c, "cj", "ㄝˇ");
  // checkEq(&container, &c, "cl", "ㄝˋ");
  // checkEq(&container, &c, "cd", "ㄝ˙");
  checkEq(&container, &c, "h ", "ㄞ ");
  checkEq(&container, &c, "t ", "ㄦ ");
  checkEq(&container, &c, "tf", "ㄦˊ");
  checkEq(&container, &c, "tj", "ㄦˇ");
  checkEq(&container, &c, "tl", "ㄦˋ");
  checkEq(&container, &c, "td", "ㄦ˙");
  checkEq(&container, &c, "ic", "ㄧㄝ");
  checkEq(&container, &c, "icf", "ㄧㄝˊ");
  checkEq(&container, &c, "icj", "ㄧㄝˇ");
  checkEq(&container, &c, "icl", "ㄧㄝˋ");
  checkEq(&container, &c, "icd", "ㄧㄝ˙");
  checkEq(&container, &c, "yc", "ㄩㄝ");
  checkEq(&container, &c, "ycj", "ㄩㄝˇ");
  checkEq(&container, &c, "ycl", "ㄩㄝˋ");
  ASSERT_TRUE(container.empty());
}

}  // namespace Tekkon
